{"version":3,"file":"NcProgressBar-D7zYeXBH-uJjZguS5.chunk.mjs","sources":["../node_modules/p-timeout/index.js","../node_modules/p-queue/dist/lower-bound.js","../node_modules/p-queue/dist/priority-queue.js","../node_modules/p-queue/dist/index.js","../node_modules/@nextcloud/vue/dist/chunks/NcProgressBar-D7zYeXBH.mjs"],"sourcesContent":["export class TimeoutError extends Error {\n\tconstructor(message) {\n\t\tsuper(message);\n\t\tthis.name = 'TimeoutError';\n\t}\n}\n\n/**\nAn error to be thrown when the request is aborted by AbortController.\nDOMException is thrown instead of this Error when DOMException is available.\n*/\nexport class AbortError extends Error {\n\tconstructor(message) {\n\t\tsuper();\n\t\tthis.name = 'AbortError';\n\t\tthis.message = message;\n\t}\n}\n\n/**\nTODO: Remove AbortError and just throw DOMException when targeting Node 18.\n*/\nconst getDOMException = errorMessage => globalThis.DOMException === undefined\n\t? new AbortError(errorMessage)\n\t: new DOMException(errorMessage);\n\n/**\nTODO: Remove below function and just 'reject(signal.reason)' when targeting Node 18.\n*/\nconst getAbortedReason = signal => {\n\tconst reason = signal.reason === undefined\n\t\t? getDOMException('This operation was aborted.')\n\t\t: signal.reason;\n\n\treturn reason instanceof Error ? reason : getDOMException(reason);\n};\n\nexport default function pTimeout(promise, options) {\n\tconst {\n\t\tmilliseconds,\n\t\tfallback,\n\t\tmessage,\n\t\tcustomTimers = {setTimeout, clearTimeout},\n\t} = options;\n\n\tlet timer;\n\n\tconst wrappedPromise = new Promise((resolve, reject) => {\n\t\tif (typeof milliseconds !== 'number' || Math.sign(milliseconds) !== 1) {\n\t\t\tthrow new TypeError(`Expected \\`milliseconds\\` to be a positive number, got \\`${milliseconds}\\``);\n\t\t}\n\n\t\tif (options.signal) {\n\t\t\tconst {signal} = options;\n\t\t\tif (signal.aborted) {\n\t\t\t\treject(getAbortedReason(signal));\n\t\t\t}\n\n\t\t\tsignal.addEventListener('abort', () => {\n\t\t\t\treject(getAbortedReason(signal));\n\t\t\t});\n\t\t}\n\n\t\tif (milliseconds === Number.POSITIVE_INFINITY) {\n\t\t\tpromise.then(resolve, reject);\n\t\t\treturn;\n\t\t}\n\n\t\t// We create the error outside of `setTimeout` to preserve the stack trace.\n\t\tconst timeoutError = new TimeoutError();\n\n\t\ttimer = customTimers.setTimeout.call(undefined, () => {\n\t\t\tif (fallback) {\n\t\t\t\ttry {\n\t\t\t\t\tresolve(fallback());\n\t\t\t\t} catch (error) {\n\t\t\t\t\treject(error);\n\t\t\t\t}\n\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\tif (typeof promise.cancel === 'function') {\n\t\t\t\tpromise.cancel();\n\t\t\t}\n\n\t\t\tif (message === false) {\n\t\t\t\tresolve();\n\t\t\t} else if (message instanceof Error) {\n\t\t\t\treject(message);\n\t\t\t} else {\n\t\t\t\ttimeoutError.message = message ?? `Promise timed out after ${milliseconds} milliseconds`;\n\t\t\t\treject(timeoutError);\n\t\t\t}\n\t\t}, milliseconds);\n\n\t\t(async () => {\n\t\t\ttry {\n\t\t\t\tresolve(await promise);\n\t\t\t} catch (error) {\n\t\t\t\treject(error);\n\t\t\t}\n\t\t})();\n\t});\n\n\tconst cancelablePromise = wrappedPromise.finally(() => {\n\t\tcancelablePromise.clear();\n\t});\n\n\tcancelablePromise.clear = () => {\n\t\tcustomTimers.clearTimeout.call(undefined, timer);\n\t\ttimer = undefined;\n\t};\n\n\treturn cancelablePromise;\n}\n","// Port of lower_bound from https://en.cppreference.com/w/cpp/algorithm/lower_bound\n// Used to compute insertion index to keep queue sorted after insertion\nexport default function lowerBound(array, value, comparator) {\n    let first = 0;\n    let count = array.length;\n    while (count > 0) {\n        const step = Math.trunc(count / 2);\n        let it = first + step;\n        if (comparator(array[it], value) <= 0) {\n            first = ++it;\n            count -= step + 1;\n        }\n        else {\n            count = step;\n        }\n    }\n    return first;\n}\n","import lowerBound from './lower-bound.js';\nexport default class PriorityQueue {\n    #queue = [];\n    enqueue(run, options) {\n        options = {\n            priority: 0,\n            ...options,\n        };\n        const element = {\n            priority: options.priority,\n            id: options.id,\n            run,\n        };\n        if (this.size === 0 || this.#queue[this.size - 1].priority >= options.priority) {\n            this.#queue.push(element);\n            return;\n        }\n        const index = lowerBound(this.#queue, element, (a, b) => b.priority - a.priority);\n        this.#queue.splice(index, 0, element);\n    }\n    setPriority(id, priority) {\n        const index = this.#queue.findIndex((element) => element.id === id);\n        if (index === -1) {\n            throw new ReferenceError(`No promise function with the id \"${id}\" exists in the queue.`);\n        }\n        const [item] = this.#queue.splice(index, 1);\n        this.enqueue(item.run, { priority, id });\n    }\n    dequeue() {\n        const item = this.#queue.shift();\n        return item?.run;\n    }\n    filter(options) {\n        return this.#queue.filter((element) => element.priority === options.priority).map((element) => element.run);\n    }\n    get size() {\n        return this.#queue.length;\n    }\n}\n","import { EventEmitter } from 'eventemitter3';\nimport pTimeout, { TimeoutError } from 'p-timeout';\nimport PriorityQueue from './priority-queue.js';\n/**\nPromise queue with concurrency control.\n*/\nexport default class PQueue extends EventEmitter {\n    #carryoverConcurrencyCount;\n    #isIntervalIgnored;\n    #intervalCount = 0;\n    #intervalCap;\n    #interval;\n    #intervalEnd = 0;\n    #intervalId;\n    #timeoutId;\n    #queue;\n    #queueClass;\n    #pending = 0;\n    // The `!` is needed because of https://github.com/microsoft/TypeScript/issues/32194\n    #concurrency;\n    #isPaused;\n    #throwOnTimeout;\n    // Use to assign a unique identifier to a promise function, if not explicitly specified\n    #idAssigner = 1n;\n    /**\n    Per-operation timeout in milliseconds. Operations fulfill once `timeout` elapses if they haven't already.\n\n    Applies to each future operation.\n    */\n    timeout;\n    // TODO: The `throwOnTimeout` option should affect the return types of `add()` and `addAll()`\n    constructor(options) {\n        super();\n        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions\n        options = {\n            carryoverConcurrencyCount: false,\n            intervalCap: Number.POSITIVE_INFINITY,\n            interval: 0,\n            concurrency: Number.POSITIVE_INFINITY,\n            autoStart: true,\n            queueClass: PriorityQueue,\n            ...options,\n        };\n        if (!(typeof options.intervalCap === 'number' && options.intervalCap >= 1)) {\n            throw new TypeError(`Expected \\`intervalCap\\` to be a number from 1 and up, got \\`${options.intervalCap?.toString() ?? ''}\\` (${typeof options.intervalCap})`);\n        }\n        if (options.interval === undefined || !(Number.isFinite(options.interval) && options.interval >= 0)) {\n            throw new TypeError(`Expected \\`interval\\` to be a finite number >= 0, got \\`${options.interval?.toString() ?? ''}\\` (${typeof options.interval})`);\n        }\n        this.#carryoverConcurrencyCount = options.carryoverConcurrencyCount;\n        this.#isIntervalIgnored = options.intervalCap === Number.POSITIVE_INFINITY || options.interval === 0;\n        this.#intervalCap = options.intervalCap;\n        this.#interval = options.interval;\n        this.#queue = new options.queueClass();\n        this.#queueClass = options.queueClass;\n        this.concurrency = options.concurrency;\n        this.timeout = options.timeout;\n        this.#throwOnTimeout = options.throwOnTimeout === true;\n        this.#isPaused = options.autoStart === false;\n    }\n    get #doesIntervalAllowAnother() {\n        return this.#isIntervalIgnored || this.#intervalCount < this.#intervalCap;\n    }\n    get #doesConcurrentAllowAnother() {\n        return this.#pending < this.#concurrency;\n    }\n    #next() {\n        this.#pending--;\n        this.#tryToStartAnother();\n        this.emit('next');\n    }\n    #onResumeInterval() {\n        this.#onInterval();\n        this.#initializeIntervalIfNeeded();\n        this.#timeoutId = undefined;\n    }\n    get #isIntervalPaused() {\n        const now = Date.now();\n        if (this.#intervalId === undefined) {\n            const delay = this.#intervalEnd - now;\n            if (delay < 0) {\n                // Act as the interval was done\n                // We don't need to resume it here because it will be resumed on line 160\n                this.#intervalCount = (this.#carryoverConcurrencyCount) ? this.#pending : 0;\n            }\n            else {\n                // Act as the interval is pending\n                if (this.#timeoutId === undefined) {\n                    this.#timeoutId = setTimeout(() => {\n                        this.#onResumeInterval();\n                    }, delay);\n                }\n                return true;\n            }\n        }\n        return false;\n    }\n    #tryToStartAnother() {\n        if (this.#queue.size === 0) {\n            // We can clear the interval (\"pause\")\n            // Because we can redo it later (\"resume\")\n            if (this.#intervalId) {\n                clearInterval(this.#intervalId);\n            }\n            this.#intervalId = undefined;\n            this.emit('empty');\n            if (this.#pending === 0) {\n                this.emit('idle');\n            }\n            return false;\n        }\n        if (!this.#isPaused) {\n            const canInitializeInterval = !this.#isIntervalPaused;\n            if (this.#doesIntervalAllowAnother && this.#doesConcurrentAllowAnother) {\n                const job = this.#queue.dequeue();\n                if (!job) {\n                    return false;\n                }\n                this.emit('active');\n                job();\n                if (canInitializeInterval) {\n                    this.#initializeIntervalIfNeeded();\n                }\n                return true;\n            }\n        }\n        return false;\n    }\n    #initializeIntervalIfNeeded() {\n        if (this.#isIntervalIgnored || this.#intervalId !== undefined) {\n            return;\n        }\n        this.#intervalId = setInterval(() => {\n            this.#onInterval();\n        }, this.#interval);\n        this.#intervalEnd = Date.now() + this.#interval;\n    }\n    #onInterval() {\n        if (this.#intervalCount === 0 && this.#pending === 0 && this.#intervalId) {\n            clearInterval(this.#intervalId);\n            this.#intervalId = undefined;\n        }\n        this.#intervalCount = this.#carryoverConcurrencyCount ? this.#pending : 0;\n        this.#processQueue();\n    }\n    /**\n    Executes all queued functions until it reaches the limit.\n    */\n    #processQueue() {\n        // eslint-disable-next-line no-empty\n        while (this.#tryToStartAnother()) { }\n    }\n    get concurrency() {\n        return this.#concurrency;\n    }\n    set concurrency(newConcurrency) {\n        if (!(typeof newConcurrency === 'number' && newConcurrency >= 1)) {\n            throw new TypeError(`Expected \\`concurrency\\` to be a number from 1 and up, got \\`${newConcurrency}\\` (${typeof newConcurrency})`);\n        }\n        this.#concurrency = newConcurrency;\n        this.#processQueue();\n    }\n    async #throwOnAbort(signal) {\n        return new Promise((_resolve, reject) => {\n            signal.addEventListener('abort', () => {\n                reject(signal.reason);\n            }, { once: true });\n        });\n    }\n    /**\n    Updates the priority of a promise function by its id, affecting its execution order. Requires a defined concurrency limit to take effect.\n\n    For example, this can be used to prioritize a promise function to run earlier.\n\n    ```js\n    import PQueue from 'p-queue';\n\n    const queue = new PQueue({concurrency: 1});\n\n    queue.add(async () => '🦄', {priority: 1});\n    queue.add(async () => '🦀', {priority: 0, id: '🦀'});\n    queue.add(async () => '🦄', {priority: 1});\n    queue.add(async () => '🦄', {priority: 1});\n\n    queue.setPriority('🦀', 2);\n    ```\n\n    In this case, the promise function with `id: '🦀'` runs second.\n\n    You can also deprioritize a promise function to delay its execution:\n\n    ```js\n    import PQueue from 'p-queue';\n\n    const queue = new PQueue({concurrency: 1});\n\n    queue.add(async () => '🦄', {priority: 1});\n    queue.add(async () => '🦀', {priority: 1, id: '🦀'});\n    queue.add(async () => '🦄');\n    queue.add(async () => '🦄', {priority: 0});\n\n    queue.setPriority('🦀', -1);\n    ```\n    Here, the promise function with `id: '🦀'` executes last.\n    */\n    setPriority(id, priority) {\n        this.#queue.setPriority(id, priority);\n    }\n    async add(function_, options = {}) {\n        // In case `id` is not defined.\n        options.id ??= (this.#idAssigner++).toString();\n        options = {\n            timeout: this.timeout,\n            throwOnTimeout: this.#throwOnTimeout,\n            ...options,\n        };\n        return new Promise((resolve, reject) => {\n            this.#queue.enqueue(async () => {\n                this.#pending++;\n                try {\n                    options.signal?.throwIfAborted();\n                    this.#intervalCount++;\n                    let operation = function_({ signal: options.signal });\n                    if (options.timeout) {\n                        operation = pTimeout(Promise.resolve(operation), { milliseconds: options.timeout });\n                    }\n                    if (options.signal) {\n                        operation = Promise.race([operation, this.#throwOnAbort(options.signal)]);\n                    }\n                    const result = await operation;\n                    resolve(result);\n                    this.emit('completed', result);\n                }\n                catch (error) {\n                    if (error instanceof TimeoutError && !options.throwOnTimeout) {\n                        resolve();\n                        return;\n                    }\n                    reject(error);\n                    this.emit('error', error);\n                }\n                finally {\n                    this.#next();\n                }\n            }, options);\n            this.emit('add');\n            this.#tryToStartAnother();\n        });\n    }\n    async addAll(functions, options) {\n        return Promise.all(functions.map(async (function_) => this.add(function_, options)));\n    }\n    /**\n    Start (or resume) executing enqueued tasks within concurrency limit. No need to call this if queue is not paused (via `options.autoStart = false` or by `.pause()` method.)\n    */\n    start() {\n        if (!this.#isPaused) {\n            return this;\n        }\n        this.#isPaused = false;\n        this.#processQueue();\n        return this;\n    }\n    /**\n    Put queue execution on hold.\n    */\n    pause() {\n        this.#isPaused = true;\n    }\n    /**\n    Clear the queue.\n    */\n    clear() {\n        this.#queue = new this.#queueClass();\n    }\n    /**\n    Can be called multiple times. Useful if you for example add additional items at a later time.\n\n    @returns A promise that settles when the queue becomes empty.\n    */\n    async onEmpty() {\n        // Instantly resolve if the queue is empty\n        if (this.#queue.size === 0) {\n            return;\n        }\n        await this.#onEvent('empty');\n    }\n    /**\n    @returns A promise that settles when the queue size is less than the given limit: `queue.size < limit`.\n\n    If you want to avoid having the queue grow beyond a certain size you can `await queue.onSizeLessThan()` before adding a new item.\n\n    Note that this only limits the number of items waiting to start. There could still be up to `concurrency` jobs already running that this call does not include in its calculation.\n    */\n    async onSizeLessThan(limit) {\n        // Instantly resolve if the queue is empty.\n        if (this.#queue.size < limit) {\n            return;\n        }\n        await this.#onEvent('next', () => this.#queue.size < limit);\n    }\n    /**\n    The difference with `.onEmpty` is that `.onIdle` guarantees that all work from the queue has finished. `.onEmpty` merely signals that the queue is empty, but it could mean that some promises haven't completed yet.\n\n    @returns A promise that settles when the queue becomes empty, and all promises have completed; `queue.size === 0 && queue.pending === 0`.\n    */\n    async onIdle() {\n        // Instantly resolve if none pending and if nothing else is queued\n        if (this.#pending === 0 && this.#queue.size === 0) {\n            return;\n        }\n        await this.#onEvent('idle');\n    }\n    async #onEvent(event, filter) {\n        return new Promise(resolve => {\n            const listener = () => {\n                if (filter && !filter()) {\n                    return;\n                }\n                this.off(event, listener);\n                resolve();\n            };\n            this.on(event, listener);\n        });\n    }\n    /**\n    Size of the queue, the number of queued items waiting to run.\n    */\n    get size() {\n        return this.#queue.size;\n    }\n    /**\n    Size of the queue, filtered by the given options.\n\n    For example, this can be used to find the number of items remaining in the queue with a specific priority level.\n    */\n    sizeBy(options) {\n        // eslint-disable-next-line unicorn/no-array-callback-reference\n        return this.#queue.filter(options).length;\n    }\n    /**\n    Number of running items (no longer in the queue).\n    */\n    get pending() {\n        return this.#pending;\n    }\n    /**\n    Whether the queue is currently paused.\n    */\n    get isPaused() {\n        return this.#isPaused;\n    }\n}\n","import '../assets/NcProgressBar-CU_ib_HL.css';\nimport { useCssVars } from \"vue\";\nimport { n as normalizeComponent } from \"./_plugin-vue2_normalizer-DU4iP6Vu.mjs\";\nconst __default__ = {\n  name: \"NcProgressBar\",\n  props: {\n    /**\n     * An integer between 1 and 100\n     */\n    value: {\n      type: Number,\n      default: 0,\n      validator(value) {\n        return value >= 0 && value <= 100;\n      }\n    },\n    /**\n     * Determines the height of the progressbar.\n     * Possible values:\n     * - 'small' (default)\n     * - 'medium'\n     * - Number\n     *\n     * @type {'small'|'medium'|number}\n     */\n    size: {\n      type: [String, Number],\n      default: \"small\",\n      validator(value) {\n        return [\"small\", \"medium\"].includes(value) || typeof value === \"number\";\n      }\n    },\n    /**\n     * Applies an error color to the progressbar if true.\n     */\n    error: {\n      type: Boolean,\n      default: false\n    },\n    /**\n     * ProgressBar type\n     */\n    type: {\n      type: String,\n      default: \"linear\",\n      validator(value) {\n        return [\"linear\", \"circular\"].includes(value);\n      }\n    },\n    /**\n     * The color of the progress bar\n     */\n    color: {\n      type: String,\n      default: null\n    }\n  },\n  data() {\n    return {\n      stroke: 4\n    };\n  },\n  computed: {\n    height() {\n      if (this.type === \"circular\") {\n        if (Number.isInteger(this.size)) {\n          return this.size;\n        }\n        return 44;\n      }\n      if (this.size === \"small\") {\n        return 4;\n      } else if (this.size === \"medium\") {\n        return 6;\n      }\n      return this.size;\n    },\n    progress() {\n      return this.value / 100;\n    },\n    radius() {\n      return this.height / 2;\n    },\n    radiusNormalized() {\n      return this.radius - 3 * this.stroke;\n    },\n    circumference() {\n      return this.radiusNormalized * 2 * Math.PI;\n    }\n  }\n};\nconst __injectCSSVars__ = () => {\n  useCssVars((_vm, _setup) => ({\n    \"15a054de\": _vm.color\n  }));\n};\nconst __setup__ = __default__.setup;\n__default__.setup = __setup__ ? (props, ctx) => {\n  __injectCSSVars__();\n  return __setup__(props, ctx);\n} : __injectCSSVars__;\nconst _sfc_main = __default__;\nvar _sfc_render = function render() {\n  var _vm = this, _c = _vm._self._c;\n  return _vm.type === \"circular\" ? _c(\"span\", { staticClass: \"progress-bar progress-bar--circular\", class: { \"progress-bar--error\": _vm.error }, style: { \"--progress-bar-height\": _vm.height + \"px\" }, attrs: { \"role\": \"progressbar\", \"aria-valuenow\": _vm.value } }, [_c(\"svg\", { attrs: { \"height\": _vm.height, \"width\": _vm.height } }, [_c(\"circle\", { attrs: { \"stroke\": \"currentColor\", \"fill\": \"transparent\", \"stroke-dasharray\": `${_vm.progress * _vm.circumference} ${(1 - _vm.progress) * _vm.circumference}`, \"stroke-dashoffset\": 0.25 * _vm.circumference, \"stroke-width\": _vm.stroke, \"r\": _vm.radiusNormalized, \"cx\": _vm.radius, \"cy\": _vm.radius } }), _c(\"circle\", { attrs: { \"stroke\": \"var(--color-background-darker)\", \"fill\": \"transparent\", \"stroke-dasharray\": `${(1 - _vm.progress) * _vm.circumference} ${_vm.progress * _vm.circumference}`, \"stroke-dashoffset\": (0.25 - _vm.progress) * _vm.circumference, \"stroke-width\": _vm.stroke, \"r\": _vm.radiusNormalized, \"cx\": _vm.radius, \"cy\": _vm.radius } })])]) : _c(\"progress\", { staticClass: \"progress-bar progress-bar--linear vue\", class: { \"progress-bar--error\": _vm.error }, style: { \"--progress-bar-height\": _vm.height + \"px\" }, attrs: { \"max\": \"100\" }, domProps: { \"value\": _vm.value } });\n};\nvar _sfc_staticRenderFns = [];\nvar __component__ = /* @__PURE__ */ normalizeComponent(\n  _sfc_main,\n  _sfc_render,\n  _sfc_staticRenderFns,\n  false,\n  null,\n  \"06c9abdc\"\n);\nconst NcProgressBar = __component__.exports;\nexport {\n  NcProgressBar as N\n};\n//# sourceMappingURL=NcProgressBar-D7zYeXBH.mjs.map\n"],"names":["TimeoutError","message","AbortError","getDOMException","errorMessage","getAbortedReason","signal","reason","pTimeout","promise","options","milliseconds","fallback","customTimers","timer","cancelablePromise","resolve","reject","timeoutError","error","lowerBound","array","value","comparator","first","count","step","it","PriorityQueue","#queue","run","element","index","a","b","id","priority","item","PQueue","EventEmitter","#carryoverConcurrencyCount","#isIntervalIgnored","#intervalCount","#intervalCap","#interval","#intervalEnd","#intervalId","#timeoutId","#queueClass","#pending","#concurrency","#isPaused","#throwOnTimeout","#idAssigner","#doesIntervalAllowAnother","#doesConcurrentAllowAnother","#next","#tryToStartAnother","#onResumeInterval","#onInterval","#initializeIntervalIfNeeded","#isIntervalPaused","now","delay","canInitializeInterval","job","#processQueue","newConcurrency","#throwOnAbort","_resolve","function_","operation","result","functions","#onEvent","limit","event","filter","listener","__default__","__injectCSSVars__","useCssVars","_vm","_setup","__setup__","props","ctx","_sfc_main","_sfc_render","_c","_sfc_staticRenderFns","__component__","normalizeComponent","NcProgressBar"],"mappings":"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","x_google_ignoreList":[0,1,2,3,4]}