@igstack/app-catalog-frontend-build-vite 0.0.1

package/dist/esm/node_modules/.pnpm/chokidar@5.0.0/node_modules/chokidar/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../../../../../../../../../node_modules/.pnpm/chokidar@5.0.0/node_modules/chokidar/index.js"],"sourcesContent":["/*! chokidar - MIT License (c) 2012 Paul Miller (paulmillr.com) */\nimport { EventEmitter } from 'node:events';\nimport { stat as statcb, Stats } from 'node:fs';\nimport { readdir, stat } from 'node:fs/promises';\nimport * as sp from 'node:path';\nimport { readdirp, ReaddirpStream } from 'readdirp';\nimport { EMPTY_FN, EVENTS as EV, isIBMi, isWindows, NodeFsHandler, STR_CLOSE, STR_END, } from './handler.js';\nconst SLASH = '/';\nconst SLASH_SLASH = '//';\nconst ONE_DOT = '.';\nconst TWO_DOTS = '..';\nconst STRING_TYPE = 'string';\nconst BACK_SLASH_RE = /\\\\/g;\nconst DOUBLE_SLASH_RE = /\\/\\//g;\nconst DOT_RE = /\\..*\\.(sw[px])$|~$|\\.subl.*\\.tmp/;\nconst REPLACER_RE = /^\\.[/\\\\]/;\nfunction arrify(item) {\n    return Array.isArray(item) ? item : [item];\n}\nconst isMatcherObject = (matcher) => typeof matcher === 'object' && matcher !== null && !(matcher instanceof RegExp);\nfunction createPattern(matcher) {\n    if (typeof matcher === 'function')\n        return matcher;\n    if (typeof matcher === 'string')\n        return (string) => matcher === string;\n    if (matcher instanceof RegExp)\n        return (string) => matcher.test(string);\n    if (typeof matcher === 'object' && matcher !== null) {\n        return (string) => {\n            if (matcher.path === string)\n                return true;\n            if (matcher.recursive) {\n                const relative = sp.relative(matcher.path, string);\n                if (!relative) {\n                    return false;\n                }\n                return !relative.startsWith('..') && !sp.isAbsolute(relative);\n            }\n            return false;\n        };\n    }\n    return () => false;\n}\nfunction normalizePath(path) {\n    if (typeof path !== 'string')\n        throw new Error('string expected');\n    path = sp.normalize(path);\n    path = path.replace(/\\\\/g, '/');\n    let prepend = false;\n    if (path.startsWith('//'))\n        prepend = true;\n    path = path.replace(DOUBLE_SLASH_RE, '/');\n    if (prepend)\n        path = '/' + path;\n    return path;\n}\nfunction matchPatterns(patterns, testString, stats) {\n    const path = normalizePath(testString);\n    for (let index = 0; index < patterns.length; index++) {\n        const pattern = patterns[index];\n        if (pattern(path, stats)) {\n            return true;\n        }\n    }\n    return false;\n}\nfunction anymatch(matchers, testString) {\n    if (matchers == null) {\n        throw new TypeError('anymatch: specify first argument');\n    }\n    // Early cache for matchers.\n    const matchersArray = arrify(matchers);\n    const patterns = matchersArray.map((matcher) => createPattern(matcher));\n    if (testString == null) {\n        return (testString, stats) => {\n            return matchPatterns(patterns, testString, stats);\n        };\n    }\n    return matchPatterns(patterns, testString);\n}\nconst unifyPaths = (paths_) => {\n    const paths = arrify(paths_).flat();\n    if (!paths.every((p) => typeof p === STRING_TYPE)) {\n        throw new TypeError(`Non-string provided as watch path: ${paths}`);\n    }\n    return paths.map(normalizePathToUnix);\n};\n// If SLASH_SLASH occurs at the beginning of path, it is not replaced\n//     because \"//StoragePC/DrivePool/Movies\" is a valid network path\nconst toUnix = (string) => {\n    let str = string.replace(BACK_SLASH_RE, SLASH);\n    let prepend = false;\n    if (str.startsWith(SLASH_SLASH)) {\n        prepend = true;\n    }\n    str = str.replace(DOUBLE_SLASH_RE, SLASH);\n    if (prepend) {\n        str = SLASH + str;\n    }\n    return str;\n};\n// Our version of upath.normalize\n// TODO: this is not equal to path-normalize module - investigate why\nconst normalizePathToUnix = (path) => toUnix(sp.normalize(toUnix(path)));\n// TODO: refactor\nconst normalizeIgnored = (cwd = '') => (path) => {\n    if (typeof path === 'string') {\n        return normalizePathToUnix(sp.isAbsolute(path) ? path : sp.join(cwd, path));\n    }\n    else {\n        return path;\n    }\n};\nconst getAbsolutePath = (path, cwd) => {\n    if (sp.isAbsolute(path)) {\n        return path;\n    }\n    return sp.join(cwd, path);\n};\nconst EMPTY_SET = Object.freeze(new Set());\n/**\n * Directory entry.\n */\nclass DirEntry {\n    path;\n    _removeWatcher;\n    items;\n    constructor(dir, removeWatcher) {\n        this.path = dir;\n        this._removeWatcher = removeWatcher;\n        this.items = new Set();\n    }\n    add(item) {\n        const { items } = this;\n        if (!items)\n            return;\n        if (item !== ONE_DOT && item !== TWO_DOTS)\n            items.add(item);\n    }\n    async remove(item) {\n        const { items } = this;\n        if (!items)\n            return;\n        items.delete(item);\n        if (items.size > 0)\n            return;\n        const dir = this.path;\n        try {\n            await readdir(dir);\n        }\n        catch (err) {\n            if (this._removeWatcher) {\n                this._removeWatcher(sp.dirname(dir), sp.basename(dir));\n            }\n        }\n    }\n    has(item) {\n        const { items } = this;\n        if (!items)\n            return;\n        return items.has(item);\n    }\n    getChildren() {\n        const { items } = this;\n        if (!items)\n            return [];\n        return [...items.values()];\n    }\n    dispose() {\n        this.items.clear();\n        this.path = '';\n        this._removeWatcher = EMPTY_FN;\n        this.items = EMPTY_SET;\n        Object.freeze(this);\n    }\n}\nconst STAT_METHOD_F = 'stat';\nconst STAT_METHOD_L = 'lstat';\nexport class WatchHelper {\n    fsw;\n    path;\n    watchPath;\n    fullWatchPath;\n    dirParts;\n    followSymlinks;\n    statMethod;\n    constructor(path, follow, fsw) {\n        this.fsw = fsw;\n        const watchPath = path;\n        this.path = path = path.replace(REPLACER_RE, '');\n        this.watchPath = watchPath;\n        this.fullWatchPath = sp.resolve(watchPath);\n        this.dirParts = [];\n        this.dirParts.forEach((parts) => {\n            if (parts.length > 1)\n                parts.pop();\n        });\n        this.followSymlinks = follow;\n        this.statMethod = follow ? STAT_METHOD_F : STAT_METHOD_L;\n    }\n    entryPath(entry) {\n        return sp.join(this.watchPath, sp.relative(this.watchPath, entry.fullPath));\n    }\n    filterPath(entry) {\n        const { stats } = entry;\n        if (stats && stats.isSymbolicLink())\n            return this.filterDir(entry);\n        const resolvedPath = this.entryPath(entry);\n        // TODO: what if stats is undefined? remove !\n        return this.fsw._isntIgnored(resolvedPath, stats) && this.fsw._hasReadPermissions(stats);\n    }\n    filterDir(entry) {\n        return this.fsw._isntIgnored(this.entryPath(entry), entry.stats);\n    }\n}\n/**\n * Watches files & directories for changes. Emitted events:\n * `add`, `addDir`, `change`, `unlink`, `unlinkDir`, `all`, `error`\n *\n *     new FSWatcher()\n *       .add(directories)\n *       .on('add', path => log('File', path, 'was added'))\n */\nexport class FSWatcher extends EventEmitter {\n    closed;\n    options;\n    _closers;\n    _ignoredPaths;\n    _throttled;\n    _streams;\n    _symlinkPaths;\n    _watched;\n    _pendingWrites;\n    _pendingUnlinks;\n    _readyCount;\n    _emitReady;\n    _closePromise;\n    _userIgnored;\n    _readyEmitted;\n    _emitRaw;\n    _boundRemove;\n    _nodeFsHandler;\n    // Not indenting methods for history sake; for now.\n    constructor(_opts = {}) {\n        super();\n        this.closed = false;\n        this._closers = new Map();\n        this._ignoredPaths = new Set();\n        this._throttled = new Map();\n        this._streams = new Set();\n        this._symlinkPaths = new Map();\n        this._watched = new Map();\n        this._pendingWrites = new Map();\n        this._pendingUnlinks = new Map();\n        this._readyCount = 0;\n        this._readyEmitted = false;\n        const awf = _opts.awaitWriteFinish;\n        const DEF_AWF = { stabilityThreshold: 2000, pollInterval: 100 };\n        const opts = {\n            // Defaults\n            persistent: true,\n            ignoreInitial: false,\n            ignorePermissionErrors: false,\n            interval: 100,\n            binaryInterval: 300,\n            followSymlinks: true,\n            usePolling: false,\n            // useAsync: false,\n            atomic: true, // NOTE: overwritten later (depends on usePolling)\n            ..._opts,\n            // Change format\n            ignored: _opts.ignored ? arrify(_opts.ignored) : arrify([]),\n            awaitWriteFinish: awf === true ? DEF_AWF : typeof awf === 'object' ? { ...DEF_AWF, ...awf } : false,\n        };\n        // Always default to polling on IBM i because fs.watch() is not available on IBM i.\n        if (isIBMi)\n            opts.usePolling = true;\n        // Editor atomic write normalization enabled by default with fs.watch\n        if (opts.atomic === undefined)\n            opts.atomic = !opts.usePolling;\n        // opts.atomic = typeof _opts.atomic === 'number' ? _opts.atomic : 100;\n        // Global override. Useful for developers, who need to force polling for all\n        // instances of chokidar, regardless of usage / dependency depth\n        const envPoll = process.env.CHOKIDAR_USEPOLLING;\n        if (envPoll !== undefined) {\n            const envLower = envPoll.toLowerCase();\n            if (envLower === 'false' || envLower === '0')\n                opts.usePolling = false;\n            else if (envLower === 'true' || envLower === '1')\n                opts.usePolling = true;\n            else\n                opts.usePolling = !!envLower;\n        }\n        const envInterval = process.env.CHOKIDAR_INTERVAL;\n        if (envInterval)\n            opts.interval = Number.parseInt(envInterval, 10);\n        // This is done to emit ready only once, but each 'add' will increase that?\n        let readyCalls = 0;\n        this._emitReady = () => {\n            readyCalls++;\n            if (readyCalls >= this._readyCount) {\n                this._emitReady = EMPTY_FN;\n                this._readyEmitted = true;\n                // use process.nextTick to allow time for listener to be bound\n                process.nextTick(() => this.emit(EV.READY));\n            }\n        };\n        this._emitRaw = (...args) => this.emit(EV.RAW, ...args);\n        this._boundRemove = this._remove.bind(this);\n        this.options = opts;\n        this._nodeFsHandler = new NodeFsHandler(this);\n        // You’re frozen when your heart’s not open.\n        Object.freeze(opts);\n    }\n    _addIgnoredPath(matcher) {\n        if (isMatcherObject(matcher)) {\n            // return early if we already have a deeply equal matcher object\n            for (const ignored of this._ignoredPaths) {\n                if (isMatcherObject(ignored) &&\n                    ignored.path === matcher.path &&\n                    ignored.recursive === matcher.recursive) {\n                    return;\n                }\n            }\n        }\n        this._ignoredPaths.add(matcher);\n    }\n    _removeIgnoredPath(matcher) {\n        this._ignoredPaths.delete(matcher);\n        // now find any matcher objects with the matcher as path\n        if (typeof matcher === 'string') {\n            for (const ignored of this._ignoredPaths) {\n                // TODO (43081j): make this more efficient.\n                // probably just make a `this._ignoredDirectories` or some\n                // such thing.\n                if (isMatcherObject(ignored) && ignored.path === matcher) {\n                    this._ignoredPaths.delete(ignored);\n                }\n            }\n        }\n    }\n    // Public methods\n    /**\n     * Adds paths to be watched on an existing FSWatcher instance.\n     * @param paths_ file or file list. Other arguments are unused\n     */\n    add(paths_, _origAdd, _internal) {\n        const { cwd } = this.options;\n        this.closed = false;\n        this._closePromise = undefined;\n        let paths = unifyPaths(paths_);\n        if (cwd) {\n            paths = paths.map((path) => {\n                const absPath = getAbsolutePath(path, cwd);\n                // Check `path` instead of `absPath` because the cwd portion can't be a glob\n                return absPath;\n            });\n        }\n        paths.forEach((path) => {\n            this._removeIgnoredPath(path);\n        });\n        this._userIgnored = undefined;\n        if (!this._readyCount)\n            this._readyCount = 0;\n        this._readyCount += paths.length;\n        Promise.all(paths.map(async (path) => {\n            const res = await this._nodeFsHandler._addToNodeFs(path, !_internal, undefined, 0, _origAdd);\n            if (res)\n                this._emitReady();\n            return res;\n        })).then((results) => {\n            if (this.closed)\n                return;\n            results.forEach((item) => {\n                if (item)\n                    this.add(sp.dirname(item), sp.basename(_origAdd || item));\n            });\n        });\n        return this;\n    }\n    /**\n     * Close watchers or start ignoring events from specified paths.\n     */\n    unwatch(paths_) {\n        if (this.closed)\n            return this;\n        const paths = unifyPaths(paths_);\n        const { cwd } = this.options;\n        paths.forEach((path) => {\n            // convert to absolute path unless relative path already matches\n            if (!sp.isAbsolute(path) && !this._closers.has(path)) {\n                if (cwd)\n                    path = sp.join(cwd, path);\n                path = sp.resolve(path);\n            }\n            this._closePath(path);\n            this._addIgnoredPath(path);\n            if (this._watched.has(path)) {\n                this._addIgnoredPath({\n                    path,\n                    recursive: true,\n                });\n            }\n            // reset the cached userIgnored anymatch fn\n            // to make ignoredPaths changes effective\n            this._userIgnored = undefined;\n        });\n        return this;\n    }\n    /**\n     * Close watchers and remove all listeners from watched paths.\n     */\n    close() {\n        if (this._closePromise) {\n            return this._closePromise;\n        }\n        this.closed = true;\n        // Memory management.\n        this.removeAllListeners();\n        const closers = [];\n        this._closers.forEach((closerList) => closerList.forEach((closer) => {\n            const promise = closer();\n            if (promise instanceof Promise)\n                closers.push(promise);\n        }));\n        this._streams.forEach((stream) => stream.destroy());\n        this._userIgnored = undefined;\n        this._readyCount = 0;\n        this._readyEmitted = false;\n        this._watched.forEach((dirent) => dirent.dispose());\n        this._closers.clear();\n        this._watched.clear();\n        this._streams.clear();\n        this._symlinkPaths.clear();\n        this._throttled.clear();\n        this._closePromise = closers.length\n            ? Promise.all(closers).then(() => undefined)\n            : Promise.resolve();\n        return this._closePromise;\n    }\n    /**\n     * Expose list of watched paths\n     * @returns for chaining\n     */\n    getWatched() {\n        const watchList = {};\n        this._watched.forEach((entry, dir) => {\n            const key = this.options.cwd ? sp.relative(this.options.cwd, dir) : dir;\n            const index = key || ONE_DOT;\n            watchList[index] = entry.getChildren().sort();\n        });\n        return watchList;\n    }\n    emitWithAll(event, args) {\n        this.emit(event, ...args);\n        if (event !== EV.ERROR)\n            this.emit(EV.ALL, event, ...args);\n    }\n    // Common helpers\n    // --------------\n    /**\n     * Normalize and emit events.\n     * Calling _emit DOES NOT MEAN emit() would be called!\n     * @param event Type of event\n     * @param path File or directory path\n     * @param stats arguments to be passed with event\n     * @returns the error if defined, otherwise the value of the FSWatcher instance's `closed` flag\n     */\n    async _emit(event, path, stats) {\n        if (this.closed)\n            return;\n        const opts = this.options;\n        if (isWindows)\n            path = sp.normalize(path);\n        if (opts.cwd)\n            path = sp.relative(opts.cwd, path);\n        const args = [path];\n        if (stats != null)\n            args.push(stats);\n        const awf = opts.awaitWriteFinish;\n        let pw;\n        if (awf && (pw = this._pendingWrites.get(path))) {\n            pw.lastChange = new Date();\n            return this;\n        }\n        if (opts.atomic) {\n            if (event === EV.UNLINK) {\n                this._pendingUnlinks.set(path, [event, ...args]);\n                setTimeout(() => {\n                    this._pendingUnlinks.forEach((entry, path) => {\n                        this.emit(...entry);\n                        this.emit(EV.ALL, ...entry);\n                        this._pendingUnlinks.delete(path);\n                    });\n                }, typeof opts.atomic === 'number' ? opts.atomic : 100);\n                return this;\n            }\n            if (event === EV.ADD && this._pendingUnlinks.has(path)) {\n                event = EV.CHANGE;\n                this._pendingUnlinks.delete(path);\n            }\n        }\n        if (awf && (event === EV.ADD || event === EV.CHANGE) && this._readyEmitted) {\n            const awfEmit = (err, stats) => {\n                if (err) {\n                    event = EV.ERROR;\n                    args[0] = err;\n                    this.emitWithAll(event, args);\n                }\n                else if (stats) {\n                    // if stats doesn't exist the file must have been deleted\n                    if (args.length > 1) {\n                        args[1] = stats;\n                    }\n                    else {\n                        args.push(stats);\n                    }\n                    this.emitWithAll(event, args);\n                }\n            };\n            this._awaitWriteFinish(path, awf.stabilityThreshold, event, awfEmit);\n            return this;\n        }\n        if (event === EV.CHANGE) {\n            const isThrottled = !this._throttle(EV.CHANGE, path, 50);\n            if (isThrottled)\n                return this;\n        }\n        if (opts.alwaysStat &&\n            stats === undefined &&\n            (event === EV.ADD || event === EV.ADD_DIR || event === EV.CHANGE)) {\n            const fullPath = opts.cwd ? sp.join(opts.cwd, path) : path;\n            let stats;\n            try {\n                stats = await stat(fullPath);\n            }\n            catch (err) {\n                // do nothing\n            }\n            // Suppress event when fs_stat fails, to avoid sending undefined 'stat'\n            if (!stats || this.closed)\n                return;\n            args.push(stats);\n        }\n        this.emitWithAll(event, args);\n        return this;\n    }\n    /**\n     * Common handler for errors\n     * @returns The error if defined, otherwise the value of the FSWatcher instance's `closed` flag\n     */\n    _handleError(error) {\n        const code = error && error.code;\n        if (error &&\n            code !== 'ENOENT' &&\n            code !== 'ENOTDIR' &&\n            (!this.options.ignorePermissionErrors || (code !== 'EPERM' && code !== 'EACCES'))) {\n            this.emit(EV.ERROR, error);\n        }\n        return error || this.closed;\n    }\n    /**\n     * Helper utility for throttling\n     * @param actionType type being throttled\n     * @param path being acted upon\n     * @param timeout duration of time to suppress duplicate actions\n     * @returns tracking object or false if action should be suppressed\n     */\n    _throttle(actionType, path, timeout) {\n        if (!this._throttled.has(actionType)) {\n            this._throttled.set(actionType, new Map());\n        }\n        const action = this._throttled.get(actionType);\n        if (!action)\n            throw new Error('invalid throttle');\n        const actionPath = action.get(path);\n        if (actionPath) {\n            actionPath.count++;\n            return false;\n        }\n        // eslint-disable-next-line prefer-const\n        let timeoutObject;\n        const clear = () => {\n            const item = action.get(path);\n            const count = item ? item.count : 0;\n            action.delete(path);\n            clearTimeout(timeoutObject);\n            if (item)\n                clearTimeout(item.timeoutObject);\n            return count;\n        };\n        timeoutObject = setTimeout(clear, timeout);\n        const thr = { timeoutObject, clear, count: 0 };\n        action.set(path, thr);\n        return thr;\n    }\n    _incrReadyCount() {\n        return this._readyCount++;\n    }\n    /**\n     * Awaits write operation to finish.\n     * Polls a newly created file for size variations. When files size does not change for 'threshold' milliseconds calls callback.\n     * @param path being acted upon\n     * @param threshold Time in milliseconds a file size must be fixed before acknowledging write OP is finished\n     * @param event\n     * @param awfEmit Callback to be called when ready for event to be emitted.\n     */\n    _awaitWriteFinish(path, threshold, event, awfEmit) {\n        const awf = this.options.awaitWriteFinish;\n        if (typeof awf !== 'object')\n            return;\n        const pollInterval = awf.pollInterval;\n        let timeoutHandler;\n        let fullPath = path;\n        if (this.options.cwd && !sp.isAbsolute(path)) {\n            fullPath = sp.join(this.options.cwd, path);\n        }\n        const now = new Date();\n        const writes = this._pendingWrites;\n        function awaitWriteFinishFn(prevStat) {\n            statcb(fullPath, (err, curStat) => {\n                if (err || !writes.has(path)) {\n                    if (err && err.code !== 'ENOENT')\n                        awfEmit(err);\n                    return;\n                }\n                const now = Number(new Date());\n                if (prevStat && curStat.size !== prevStat.size) {\n                    writes.get(path).lastChange = now;\n                }\n                const pw = writes.get(path);\n                const df = now - pw.lastChange;\n                if (df >= threshold) {\n                    writes.delete(path);\n                    awfEmit(undefined, curStat);\n                }\n                else {\n                    timeoutHandler = setTimeout(awaitWriteFinishFn, pollInterval, curStat);\n                }\n            });\n        }\n        if (!writes.has(path)) {\n            writes.set(path, {\n                lastChange: now,\n                cancelWait: () => {\n                    writes.delete(path);\n                    clearTimeout(timeoutHandler);\n                    return event;\n                },\n            });\n            timeoutHandler = setTimeout(awaitWriteFinishFn, pollInterval);\n        }\n    }\n    /**\n     * Determines whether user has asked to ignore this path.\n     */\n    _isIgnored(path, stats) {\n        if (this.options.atomic && DOT_RE.test(path))\n            return true;\n        if (!this._userIgnored) {\n            const { cwd } = this.options;\n            const ign = this.options.ignored;\n            const ignored = (ign || []).map(normalizeIgnored(cwd));\n            const ignoredPaths = [...this._ignoredPaths];\n            const list = [...ignoredPaths.map(normalizeIgnored(cwd)), ...ignored];\n            this._userIgnored = anymatch(list, undefined);\n        }\n        return this._userIgnored(path, stats);\n    }\n    _isntIgnored(path, stat) {\n        return !this._isIgnored(path, stat);\n    }\n    /**\n     * Provides a set of common helpers and properties relating to symlink handling.\n     * @param path file or directory pattern being watched\n     */\n    _getWatchHelpers(path) {\n        return new WatchHelper(path, this.options.followSymlinks, this);\n    }\n    // Directory helpers\n    // -----------------\n    /**\n     * Provides directory tracking objects\n     * @param directory path of the directory\n     */\n    _getWatchedDir(directory) {\n        const dir = sp.resolve(directory);\n        if (!this._watched.has(dir))\n            this._watched.set(dir, new DirEntry(dir, this._boundRemove));\n        return this._watched.get(dir);\n    }\n    // File helpers\n    // ------------\n    /**\n     * Check for read permissions: https://stackoverflow.com/a/11781404/1358405\n     */\n    _hasReadPermissions(stats) {\n        if (this.options.ignorePermissionErrors)\n            return true;\n        return Boolean(Number(stats.mode) & 0o400);\n    }\n    /**\n     * Handles emitting unlink events for\n     * files and directories, and via recursion, for\n     * files and directories within directories that are unlinked\n     * @param directory within which the following item is located\n     * @param item      base path of item/directory\n     */\n    _remove(directory, item, isDirectory) {\n        // if what is being deleted is a directory, get that directory's paths\n        // for recursive deleting and cleaning of watched object\n        // if it is not a directory, nestedDirectoryChildren will be empty array\n        const path = sp.join(directory, item);\n        const fullPath = sp.resolve(path);\n        isDirectory =\n            isDirectory != null ? isDirectory : this._watched.has(path) || this._watched.has(fullPath);\n        // prevent duplicate handling in case of arriving here nearly simultaneously\n        // via multiple paths (such as _handleFile and _handleDir)\n        if (!this._throttle('remove', path, 100))\n            return;\n        // if the only watched file is removed, watch for its return\n        if (!isDirectory && this._watched.size === 1) {\n            this.add(directory, item, true);\n        }\n        // This will create a new entry in the watched object in either case\n        // so we got to do the directory check beforehand\n        const wp = this._getWatchedDir(path);\n        const nestedDirectoryChildren = wp.getChildren();\n        // Recursively remove children directories / files.\n        nestedDirectoryChildren.forEach((nested) => this._remove(path, nested));\n        // Check if item was on the watched list and remove it\n        const parent = this._getWatchedDir(directory);\n        const wasTracked = parent.has(item);\n        parent.remove(item);\n        // Fixes issue #1042 -> Relative paths were detected and added as symlinks\n        // (https://github.com/paulmillr/chokidar/blob/e1753ddbc9571bdc33b4a4af172d52cb6e611c10/lib/nodefs-handler.js#L612),\n        // but never removed from the map in case the path was deleted.\n        // This leads to an incorrect state if the path was recreated:\n        // https://github.com/paulmillr/chokidar/blob/e1753ddbc9571bdc33b4a4af172d52cb6e611c10/lib/nodefs-handler.js#L553\n        if (this._symlinkPaths.has(fullPath)) {\n            this._symlinkPaths.delete(fullPath);\n        }\n        // If we wait for this file to be fully written, cancel the wait.\n        let relPath = path;\n        if (this.options.cwd)\n            relPath = sp.relative(this.options.cwd, path);\n        if (this.options.awaitWriteFinish && this._pendingWrites.has(relPath)) {\n            const event = this._pendingWrites.get(relPath).cancelWait();\n            if (event === EV.ADD)\n                return;\n        }\n        // The Entry will either be a directory that just got removed\n        // or a bogus entry to a file, in either case we have to remove it\n        this._watched.delete(path);\n        this._watched.delete(fullPath);\n        const eventName = isDirectory ? EV.UNLINK_DIR : EV.UNLINK;\n        if (wasTracked && !this._isIgnored(path))\n            this._emit(eventName, path);\n        // Avoid conflicts if we later create another file with the same name\n        this._closePath(path);\n    }\n    /**\n     * Closes all watchers for a path\n     */\n    _closePath(path) {\n        this._closeFile(path);\n        const dir = sp.dirname(path);\n        this._getWatchedDir(dir).remove(sp.basename(path));\n    }\n    /**\n     * Closes only file-specific watchers\n     */\n    _closeFile(path) {\n        const closers = this._closers.get(path);\n        if (!closers)\n            return;\n        closers.forEach((closer) => closer());\n        this._closers.delete(path);\n    }\n    _addPathCloser(path, closer) {\n        if (!closer)\n            return;\n        let list = this._closers.get(path);\n        if (!list) {\n            list = [];\n            this._closers.set(path, list);\n        }\n        list.push(closer);\n    }\n    _readdirp(root, opts) {\n        if (this.closed)\n            return;\n        const options = { type: EV.ALL, alwaysStat: true, lstat: true, ...opts, depth: 0 };\n        let stream = readdirp(root, options);\n        this._streams.add(stream);\n        stream.once(STR_CLOSE, () => {\n            stream = undefined;\n        });\n        stream.once(STR_END, () => {\n            if (stream) {\n                this._streams.delete(stream);\n                stream = undefined;\n            }\n        });\n        return stream;\n    }\n}\n/**\n * Instantiates watcher with paths to be tracked.\n * @param paths file / directory paths\n * @param options opts, such as `atomic`, `awaitWriteFinish`, `ignored`, and others\n * @returns an instance of FSWatcher for chaining.\n * @example\n * const watcher = watch('.').on('all', (event, path) => { console.log(event, path); });\n * watch('.', { atomic: true, awaitWriteFinish: true, ignored: (f, stats) => stats?.isFile() && !f.endsWith('.js') })\n */\nexport function watch(paths, options = {}) {\n    const watcher = new FSWatcher(options);\n    watcher.add(paths);\n    return watcher;\n}\nexport default { watch: watch, FSWatcher: FSWatcher };\n"],"names":["testString","EV","path","stats","statcb","now","stat"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/esm/node_modules/.pnpm/readdirp@5.0.0/node_modules/readdirp/index.js

@@ -0,0 +1,241 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+import { lstat, stat, readdir, realpath } from "node:fs/promises";
+import { resolve, join, relative, sep } from "node:path";
+import { Readable } from "node:stream";
+const EntryTypes = {
+  FILE_TYPE: "files",
+  DIR_TYPE: "directories",
+  FILE_DIR_TYPE: "files_directories",
+  EVERYTHING_TYPE: "all"
+};
+const defaultOptions = {
+  root: ".",
+  fileFilter: (_entryInfo) => true,
+  directoryFilter: (_entryInfo) => true,
+  type: EntryTypes.FILE_TYPE,
+  lstat: false,
+  depth: 2147483648,
+  alwaysStat: false,
+  highWaterMark: 4096
+};
+Object.freeze(defaultOptions);
+const RECURSIVE_ERROR_CODE = "READDIRP_RECURSIVE_ERROR";
+const NORMAL_FLOW_ERRORS = /* @__PURE__ */ new Set(["ENOENT", "EPERM", "EACCES", "ELOOP", RECURSIVE_ERROR_CODE]);
+const ALL_TYPES = [
+  EntryTypes.DIR_TYPE,
+  EntryTypes.EVERYTHING_TYPE,
+  EntryTypes.FILE_DIR_TYPE,
+  EntryTypes.FILE_TYPE
+];
+const DIR_TYPES = /* @__PURE__ */ new Set([
+  EntryTypes.DIR_TYPE,
+  EntryTypes.EVERYTHING_TYPE,
+  EntryTypes.FILE_DIR_TYPE
+]);
+const FILE_TYPES = /* @__PURE__ */ new Set([
+  EntryTypes.EVERYTHING_TYPE,
+  EntryTypes.FILE_DIR_TYPE,
+  EntryTypes.FILE_TYPE
+]);
+const isNormalFlowError = (error) => NORMAL_FLOW_ERRORS.has(error.code);
+const wantBigintFsStats = process.platform === "win32";
+const emptyFn = (_entryInfo) => true;
+const normalizeFilter = (filter) => {
+  if (filter === void 0)
+    return emptyFn;
+  if (typeof filter === "function")
+    return filter;
+  if (typeof filter === "string") {
+    const fl = filter.trim();
+    return (entry) => entry.basename === fl;
+  }
+  if (Array.isArray(filter)) {
+    const trItems = filter.map((item) => item.trim());
+    return (entry) => trItems.some((f) => entry.basename === f);
+  }
+  return emptyFn;
+};
+class ReaddirpStream extends Readable {
+  constructor(options = {}) {
+    super({
+      objectMode: true,
+      autoDestroy: true,
+      highWaterMark: options.highWaterMark
+    });
+    __publicField(this, "parents");
+    __publicField(this, "reading");
+    __publicField(this, "parent");
+    __publicField(this, "_stat");
+    __publicField(this, "_maxDepth");
+    __publicField(this, "_wantsDir");
+    __publicField(this, "_wantsFile");
+    __publicField(this, "_wantsEverything");
+    __publicField(this, "_root");
+    __publicField(this, "_isDirent");
+    __publicField(this, "_statsProp");
+    __publicField(this, "_rdOptions");
+    __publicField(this, "_fileFilter");
+    __publicField(this, "_directoryFilter");
+    const opts = { ...defaultOptions, ...options };
+    const { root, type } = opts;
+    this._fileFilter = normalizeFilter(opts.fileFilter);
+    this._directoryFilter = normalizeFilter(opts.directoryFilter);
+    const statMethod = opts.lstat ? lstat : stat;
+    if (wantBigintFsStats) {
+      this._stat = (path) => statMethod(path, { bigint: true });
+    } else {
+      this._stat = statMethod;
+    }
+    this._maxDepth = opts.depth != null && Number.isSafeInteger(opts.depth) ? opts.depth : defaultOptions.depth;
+    this._wantsDir = type ? DIR_TYPES.has(type) : false;
+    this._wantsFile = type ? FILE_TYPES.has(type) : false;
+    this._wantsEverything = type === EntryTypes.EVERYTHING_TYPE;
+    this._root = resolve(root);
+    this._isDirent = !opts.alwaysStat;
+    this._statsProp = this._isDirent ? "dirent" : "stats";
+    this._rdOptions = { encoding: "utf8", withFileTypes: this._isDirent };
+    this.parents = [this._exploreDir(root, 1)];
+    this.reading = false;
+    this.parent = void 0;
+  }
+  async _read(batch) {
+    if (this.reading)
+      return;
+    this.reading = true;
+    try {
+      while (!this.destroyed && batch > 0) {
+        const par = this.parent;
+        const fil = par && par.files;
+        if (fil && fil.length > 0) {
+          const { path, depth } = par;
+          const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path));
+          const awaited = await Promise.all(slice);
+          for (const entry of awaited) {
+            if (!entry)
+              continue;
+            if (this.destroyed)
+              return;
+            const entryType = await this._getEntryType(entry);
+            if (entryType === "directory" && this._directoryFilter(entry)) {
+              if (depth <= this._maxDepth) {
+                this.parents.push(this._exploreDir(entry.fullPath, depth + 1));
+              }
+              if (this._wantsDir) {
+                this.push(entry);
+                batch--;
+              }
+            } else if ((entryType === "file" || this._includeAsFile(entry)) && this._fileFilter(entry)) {
+              if (this._wantsFile) {
+                this.push(entry);
+                batch--;
+              }
+            }
+          }
+        } else {
+          const parent = this.parents.pop();
+          if (!parent) {
+            this.push(null);
+            break;
+          }
+          this.parent = await parent;
+          if (this.destroyed)
+            return;
+        }
+      }
+    } catch (error) {
+      this.destroy(error);
+    } finally {
+      this.reading = false;
+    }
+  }
+  async _exploreDir(path, depth) {
+    let files;
+    try {
+      files = await readdir(path, this._rdOptions);
+    } catch (error) {
+      this._onError(error);
+    }
+    return { files, depth, path };
+  }
+  async _formatEntry(dirent, path) {
+    let entry;
+    const basename = this._isDirent ? dirent.name : dirent;
+    try {
+      const fullPath = resolve(join(path, basename));
+      entry = { path: relative(this._root, fullPath), fullPath, basename };
+      entry[this._statsProp] = this._isDirent ? dirent : await this._stat(fullPath);
+    } catch (err) {
+      this._onError(err);
+      return;
+    }
+    return entry;
+  }
+  _onError(err) {
+    if (isNormalFlowError(err) && !this.destroyed) {
+      this.emit("warn", err);
+    } else {
+      this.destroy(err);
+    }
+  }
+  async _getEntryType(entry) {
+    if (!entry && this._statsProp in entry) {
+      return "";
+    }
+    const stats = entry[this._statsProp];
+    if (stats.isFile())
+      return "file";
+    if (stats.isDirectory())
+      return "directory";
+    if (stats && stats.isSymbolicLink()) {
+      const full = entry.fullPath;
+      try {
+        const entryRealPath = await realpath(full);
+        const entryRealPathStats = await lstat(entryRealPath);
+        if (entryRealPathStats.isFile()) {
+          return "file";
+        }
+        if (entryRealPathStats.isDirectory()) {
+          const len = entryRealPath.length;
+          if (full.startsWith(entryRealPath) && full.substr(len, 1) === sep) {
+            const recursiveError = new Error(`Circular symlink detected: "${full}" points to "${entryRealPath}"`);
+            recursiveError.code = RECURSIVE_ERROR_CODE;
+            return this._onError(recursiveError);
+          }
+          return "directory";
+        }
+      } catch (error) {
+        this._onError(error);
+        return "";
+      }
+    }
+  }
+  _includeAsFile(entry) {
+    const stats = entry && entry[this._statsProp];
+    return stats && this._wantsEverything && !stats.isDirectory();
+  }
+}
+function readdirp(root, options = {}) {
+  let type = options.entryType || options.type;
+  if (type === "both")
+    type = EntryTypes.FILE_DIR_TYPE;
+  if (type)
+    options.type = type;
+  if (!root) {
+    throw new Error("readdirp: root argument is required. Usage: readdirp(root, options)");
+  } else if (typeof root !== "string") {
+    throw new TypeError("readdirp: root argument must be a string. Usage: readdirp(root, options)");
+  } else if (type && !ALL_TYPES.includes(type)) {
+    throw new Error(`readdirp: Invalid type passed. Use one of ${ALL_TYPES.join(", ")}`);
+  }
+  options.root = root;
+  return new ReaddirpStream(options);
+}
+export {
+  EntryTypes,
+  ReaddirpStream,
+  readdirp as default,
+  readdirp
+};
+//# sourceMappingURL=index.js.map

package/dist/esm/node_modules/.pnpm/readdirp@5.0.0/node_modules/readdirp/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../../../../../../../../../node_modules/.pnpm/readdirp@5.0.0/node_modules/readdirp/index.js"],"sourcesContent":["import { lstat, readdir, realpath, stat } from 'node:fs/promises';\nimport { join as pjoin, relative as prelative, resolve as presolve, sep as psep } from 'node:path';\nimport { Readable } from 'node:stream';\nexport const EntryTypes = {\n    FILE_TYPE: 'files',\n    DIR_TYPE: 'directories',\n    FILE_DIR_TYPE: 'files_directories',\n    EVERYTHING_TYPE: 'all',\n};\nconst defaultOptions = {\n    root: '.',\n    fileFilter: (_entryInfo) => true,\n    directoryFilter: (_entryInfo) => true,\n    type: EntryTypes.FILE_TYPE,\n    lstat: false,\n    depth: 2147483648,\n    alwaysStat: false,\n    highWaterMark: 4096,\n};\nObject.freeze(defaultOptions);\nconst RECURSIVE_ERROR_CODE = 'READDIRP_RECURSIVE_ERROR';\nconst NORMAL_FLOW_ERRORS = new Set(['ENOENT', 'EPERM', 'EACCES', 'ELOOP', RECURSIVE_ERROR_CODE]);\nconst ALL_TYPES = [\n    EntryTypes.DIR_TYPE,\n    EntryTypes.EVERYTHING_TYPE,\n    EntryTypes.FILE_DIR_TYPE,\n    EntryTypes.FILE_TYPE,\n];\nconst DIR_TYPES = new Set([\n    EntryTypes.DIR_TYPE,\n    EntryTypes.EVERYTHING_TYPE,\n    EntryTypes.FILE_DIR_TYPE,\n]);\nconst FILE_TYPES = new Set([\n    EntryTypes.EVERYTHING_TYPE,\n    EntryTypes.FILE_DIR_TYPE,\n    EntryTypes.FILE_TYPE,\n]);\nconst isNormalFlowError = (error) => NORMAL_FLOW_ERRORS.has(error.code);\nconst wantBigintFsStats = process.platform === 'win32';\nconst emptyFn = (_entryInfo) => true;\nconst normalizeFilter = (filter) => {\n    if (filter === undefined)\n        return emptyFn;\n    if (typeof filter === 'function')\n        return filter;\n    if (typeof filter === 'string') {\n        const fl = filter.trim();\n        return (entry) => entry.basename === fl;\n    }\n    if (Array.isArray(filter)) {\n        const trItems = filter.map((item) => item.trim());\n        return (entry) => trItems.some((f) => entry.basename === f);\n    }\n    return emptyFn;\n};\n/** Readable readdir stream, emitting new files as they're being listed. */\nexport class ReaddirpStream extends Readable {\n    parents;\n    reading;\n    parent;\n    _stat;\n    _maxDepth;\n    _wantsDir;\n    _wantsFile;\n    _wantsEverything;\n    _root;\n    _isDirent;\n    _statsProp;\n    _rdOptions;\n    _fileFilter;\n    _directoryFilter;\n    constructor(options = {}) {\n        super({\n            objectMode: true,\n            autoDestroy: true,\n            highWaterMark: options.highWaterMark,\n        });\n        const opts = { ...defaultOptions, ...options };\n        const { root, type } = opts;\n        this._fileFilter = normalizeFilter(opts.fileFilter);\n        this._directoryFilter = normalizeFilter(opts.directoryFilter);\n        const statMethod = opts.lstat ? lstat : stat;\n        // Use bigint stats if it's windows and stat() supports options (node 10+).\n        if (wantBigintFsStats) {\n            this._stat = (path) => statMethod(path, { bigint: true });\n        }\n        else {\n            this._stat = statMethod;\n        }\n        this._maxDepth =\n            opts.depth != null && Number.isSafeInteger(opts.depth) ? opts.depth : defaultOptions.depth;\n        this._wantsDir = type ? DIR_TYPES.has(type) : false;\n        this._wantsFile = type ? FILE_TYPES.has(type) : false;\n        this._wantsEverything = type === EntryTypes.EVERYTHING_TYPE;\n        this._root = presolve(root);\n        this._isDirent = !opts.alwaysStat;\n        this._statsProp = this._isDirent ? 'dirent' : 'stats';\n        this._rdOptions = { encoding: 'utf8', withFileTypes: this._isDirent };\n        // Launch stream with one parent, the root dir.\n        this.parents = [this._exploreDir(root, 1)];\n        this.reading = false;\n        this.parent = undefined;\n    }\n    async _read(batch) {\n        if (this.reading)\n            return;\n        this.reading = true;\n        try {\n            while (!this.destroyed && batch > 0) {\n                const par = this.parent;\n                const fil = par && par.files;\n                if (fil && fil.length > 0) {\n                    const { path, depth } = par;\n                    const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path));\n                    const awaited = await Promise.all(slice);\n                    for (const entry of awaited) {\n                        if (!entry)\n                            continue;\n                        if (this.destroyed)\n                            return;\n                        const entryType = await this._getEntryType(entry);\n                        if (entryType === 'directory' && this._directoryFilter(entry)) {\n                            if (depth <= this._maxDepth) {\n                                this.parents.push(this._exploreDir(entry.fullPath, depth + 1));\n                            }\n                            if (this._wantsDir) {\n                                this.push(entry);\n                                batch--;\n                            }\n                        }\n                        else if ((entryType === 'file' || this._includeAsFile(entry)) &&\n                            this._fileFilter(entry)) {\n                            if (this._wantsFile) {\n                                this.push(entry);\n                                batch--;\n                            }\n                        }\n                    }\n                }\n                else {\n                    const parent = this.parents.pop();\n                    if (!parent) {\n                        this.push(null);\n                        break;\n                    }\n                    this.parent = await parent;\n                    if (this.destroyed)\n                        return;\n                }\n            }\n        }\n        catch (error) {\n            this.destroy(error);\n        }\n        finally {\n            this.reading = false;\n        }\n    }\n    async _exploreDir(path, depth) {\n        let files;\n        try {\n            files = await readdir(path, this._rdOptions);\n        }\n        catch (error) {\n            this._onError(error);\n        }\n        return { files, depth, path };\n    }\n    async _formatEntry(dirent, path) {\n        let entry;\n        const basename = this._isDirent ? dirent.name : dirent;\n        try {\n            const fullPath = presolve(pjoin(path, basename));\n            entry = { path: prelative(this._root, fullPath), fullPath, basename };\n            entry[this._statsProp] = this._isDirent ? dirent : await this._stat(fullPath);\n        }\n        catch (err) {\n            this._onError(err);\n            return;\n        }\n        return entry;\n    }\n    _onError(err) {\n        if (isNormalFlowError(err) && !this.destroyed) {\n            this.emit('warn', err);\n        }\n        else {\n            this.destroy(err);\n        }\n    }\n    async _getEntryType(entry) {\n        // entry may be undefined, because a warning or an error were emitted\n        // and the statsProp is undefined\n        if (!entry && this._statsProp in entry) {\n            return '';\n        }\n        const stats = entry[this._statsProp];\n        if (stats.isFile())\n            return 'file';\n        if (stats.isDirectory())\n            return 'directory';\n        if (stats && stats.isSymbolicLink()) {\n            const full = entry.fullPath;\n            try {\n                const entryRealPath = await realpath(full);\n                const entryRealPathStats = await lstat(entryRealPath);\n                if (entryRealPathStats.isFile()) {\n                    return 'file';\n                }\n                if (entryRealPathStats.isDirectory()) {\n                    const len = entryRealPath.length;\n                    if (full.startsWith(entryRealPath) && full.substr(len, 1) === psep) {\n                        const recursiveError = new Error(`Circular symlink detected: \"${full}\" points to \"${entryRealPath}\"`);\n                        // @ts-ignore\n                        recursiveError.code = RECURSIVE_ERROR_CODE;\n                        return this._onError(recursiveError);\n                    }\n                    return 'directory';\n                }\n            }\n            catch (error) {\n                this._onError(error);\n                return '';\n            }\n        }\n    }\n    _includeAsFile(entry) {\n        const stats = entry && entry[this._statsProp];\n        return stats && this._wantsEverything && !stats.isDirectory();\n    }\n}\n/**\n * Streaming version: Reads all files and directories in given root recursively.\n * Consumes ~constant small amount of RAM.\n * @param root Root directory\n * @param options Options to specify root (start directory), filters and recursion depth\n */\nexport function readdirp(root, options = {}) {\n    // @ts-ignore\n    let type = options.entryType || options.type;\n    if (type === 'both')\n        type = EntryTypes.FILE_DIR_TYPE; // backwards-compatibility\n    if (type)\n        options.type = type;\n    if (!root) {\n        throw new Error('readdirp: root argument is required. Usage: readdirp(root, options)');\n    }\n    else if (typeof root !== 'string') {\n        throw new TypeError('readdirp: root argument must be a string. Usage: readdirp(root, options)');\n    }\n    else if (type && !ALL_TYPES.includes(type)) {\n        throw new Error(`readdirp: Invalid type passed. Use one of ${ALL_TYPES.join(', ')}`);\n    }\n    options.root = root;\n    return new ReaddirpStream(options);\n}\n/**\n * Promise version: Reads all files and directories in given root recursively.\n * Compared to streaming version, will consume a lot of RAM e.g. when 1 million files are listed.\n * @returns array of paths and their entry infos\n */\nexport function readdirpPromise(root, options = {}) {\n    return new Promise((resolve, reject) => {\n        const files = [];\n        readdirp(root, options)\n            .on('data', (entry) => files.push(entry))\n            .on('end', () => resolve(files))\n            .on('error', (error) => reject(error));\n    });\n}\nexport default readdirp;\n"],"names":["presolve","pjoin","prelative","psep"],"mappings":";;;;;;AAGY,MAAC,aAAa;AAAA,EACtB,WAAW;AAAA,EACX,UAAU;AAAA,EACV,eAAe;AAAA,EACf,iBAAiB;AACrB;AACA,MAAM,iBAAiB;AAAA,EACnB,MAAM;AAAA,EACN,YAAY,CAAC,eAAe;AAAA,EAC5B,iBAAiB,CAAC,eAAe;AAAA,EACjC,MAAM,WAAW;AAAA,EACjB,OAAO;AAAA,EACP,OAAO;AAAA,EACP,YAAY;AAAA,EACZ,eAAe;AACnB;AACA,OAAO,OAAO,cAAc;AAC5B,MAAM,uBAAuB;AAC7B,MAAM,qBAAqB,oBAAI,IAAI,CAAC,UAAU,SAAS,UAAU,SAAS,oBAAoB,CAAC;AAC/F,MAAM,YAAY;AAAA,EACd,WAAW;AAAA,EACX,WAAW;AAAA,EACX,WAAW;AAAA,EACX,WAAW;AACf;AACA,MAAM,YAAY,oBAAI,IAAI;AAAA,EACtB,WAAW;AAAA,EACX,WAAW;AAAA,EACX,WAAW;AACf,CAAC;AACD,MAAM,aAAa,oBAAI,IAAI;AAAA,EACvB,WAAW;AAAA,EACX,WAAW;AAAA,EACX,WAAW;AACf,CAAC;AACD,MAAM,oBAAoB,CAAC,UAAU,mBAAmB,IAAI,MAAM,IAAI;AACtE,MAAM,oBAAoB,QAAQ,aAAa;AAC/C,MAAM,UAAU,CAAC,eAAe;AAChC,MAAM,kBAAkB,CAAC,WAAW;AAChC,MAAI,WAAW;AACX,WAAO;AACX,MAAI,OAAO,WAAW;AAClB,WAAO;AACX,MAAI,OAAO,WAAW,UAAU;AAC5B,UAAM,KAAK,OAAO,KAAI;AACtB,WAAO,CAAC,UAAU,MAAM,aAAa;AAAA,EACzC;AACA,MAAI,MAAM,QAAQ,MAAM,GAAG;AACvB,UAAM,UAAU,OAAO,IAAI,CAAC,SAAS,KAAK,MAAM;AAChD,WAAO,CAAC,UAAU,QAAQ,KAAK,CAAC,MAAM,MAAM,aAAa,CAAC;AAAA,EAC9D;AACA,SAAO;AACX;AAEO,MAAM,uBAAuB,SAAS;AAAA,EAezC,YAAY,UAAU,IAAI;AACtB,UAAM;AAAA,MACF,YAAY;AAAA,MACZ,aAAa;AAAA,MACb,eAAe,QAAQ;AAAA,IACnC,CAAS;AAnBL;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAOI,UAAM,OAAO,EAAE,GAAG,gBAAgB,GAAG,QAAO;AAC5C,UAAM,EAAE,MAAM,KAAI,IAAK;AACvB,SAAK,cAAc,gBAAgB,KAAK,UAAU;AAClD,SAAK,mBAAmB,gBAAgB,KAAK,eAAe;AAC5D,UAAM,aAAa,KAAK,QAAQ,QAAQ;AAExC,QAAI,mBAAmB;AACnB,WAAK,QAAQ,CAAC,SAAS,WAAW,MAAM,EAAE,QAAQ,MAAM;AAAA,IAC5D,OACK;AACD,WAAK,QAAQ;AAAA,IACjB;AACA,SAAK,YACD,KAAK,SAAS,QAAQ,OAAO,cAAc,KAAK,KAAK,IAAI,KAAK,QAAQ,eAAe;AACzF,SAAK,YAAY,OAAO,UAAU,IAAI,IAAI,IAAI;AAC9C,SAAK,aAAa,OAAO,WAAW,IAAI,IAAI,IAAI;AAChD,SAAK,mBAAmB,SAAS,WAAW;AAC5C,SAAK,QAAQA,QAAS,IAAI;AAC1B,SAAK,YAAY,CAAC,KAAK;AACvB,SAAK,aAAa,KAAK,YAAY,WAAW;AAC9C,SAAK,aAAa,EAAE,UAAU,QAAQ,eAAe,KAAK,UAAS;AAEnE,SAAK,UAAU,CAAC,KAAK,YAAY,MAAM,CAAC,CAAC;AACzC,SAAK,UAAU;AACf,SAAK,SAAS;AAAA,EAClB;AAAA,EACA,MAAM,MAAM,OAAO;AACf,QAAI,KAAK;AACL;AACJ,SAAK,UAAU;AACf,QAAI;AACA,aAAO,CAAC,KAAK,aAAa,QAAQ,GAAG;AACjC,cAAM,MAAM,KAAK;AACjB,cAAM,MAAM,OAAO,IAAI;AACvB,YAAI,OAAO,IAAI,SAAS,GAAG;AACvB,gBAAM,EAAE,MAAM,MAAK,IAAK;AACxB,gBAAM,QAAQ,IAAI,OAAO,GAAG,KAAK,EAAE,IAAI,CAAC,WAAW,KAAK,aAAa,QAAQ,IAAI,CAAC;AAClF,gBAAM,UAAU,MAAM,QAAQ,IAAI,KAAK;AACvC,qBAAW,SAAS,SAAS;AACzB,gBAAI,CAAC;AACD;AACJ,gBAAI,KAAK;AACL;AACJ,kBAAM,YAAY,MAAM,KAAK,cAAc,KAAK;AAChD,gBAAI,cAAc,eAAe,KAAK,iBAAiB,KAAK,GAAG;AAC3D,kBAAI,SAAS,KAAK,WAAW;AACzB,qBAAK,QAAQ,KAAK,KAAK,YAAY,MAAM,UAAU,QAAQ,CAAC,CAAC;AAAA,cACjE;AACA,kBAAI,KAAK,WAAW;AAChB,qBAAK,KAAK,KAAK;AACf;AAAA,cACJ;AAAA,YACJ,YACU,cAAc,UAAU,KAAK,eAAe,KAAK,MACvD,KAAK,YAAY,KAAK,GAAG;AACzB,kBAAI,KAAK,YAAY;AACjB,qBAAK,KAAK,KAAK;AACf;AAAA,cACJ;AAAA,YACJ;AAAA,UACJ;AAAA,QACJ,OACK;AACD,gBAAM,SAAS,KAAK,QAAQ,IAAG;AAC/B,cAAI,CAAC,QAAQ;AACT,iBAAK,KAAK,IAAI;AACd;AAAA,UACJ;AACA,eAAK,SAAS,MAAM;AACpB,cAAI,KAAK;AACL;AAAA,QACR;AAAA,MACJ;AAAA,IACJ,SACO,OAAO;AACV,WAAK,QAAQ,KAAK;AAAA,IACtB,UACR;AACY,WAAK,UAAU;AAAA,IACnB;AAAA,EACJ;AAAA,EACA,MAAM,YAAY,MAAM,OAAO;AAC3B,QAAI;AACJ,QAAI;AACA,cAAQ,MAAM,QAAQ,MAAM,KAAK,UAAU;AAAA,IAC/C,SACO,OAAO;AACV,WAAK,SAAS,KAAK;AAAA,IACvB;AACA,WAAO,EAAE,OAAO,OAAO,KAAI;AAAA,EAC/B;AAAA,EACA,MAAM,aAAa,QAAQ,MAAM;AAC7B,QAAI;AACJ,UAAM,WAAW,KAAK,YAAY,OAAO,OAAO;AAChD,QAAI;AACA,YAAM,WAAWA,QAASC,KAAM,MAAM,QAAQ,CAAC;AAC/C,cAAQ,EAAE,MAAMC,SAAU,KAAK,OAAO,QAAQ,GAAG,UAAU,SAAQ;AACnE,YAAM,KAAK,UAAU,IAAI,KAAK,YAAY,SAAS,MAAM,KAAK,MAAM,QAAQ;AAAA,IAChF,SACO,KAAK;AACR,WAAK,SAAS,GAAG;AACjB;AAAA,IACJ;AACA,WAAO;AAAA,EACX;AAAA,EACA,SAAS,KAAK;AACV,QAAI,kBAAkB,GAAG,KAAK,CAAC,KAAK,WAAW;AAC3C,WAAK,KAAK,QAAQ,GAAG;AAAA,IACzB,OACK;AACD,WAAK,QAAQ,GAAG;AAAA,IACpB;AAAA,EACJ;AAAA,EACA,MAAM,cAAc,OAAO;AAGvB,QAAI,CAAC,SAAS,KAAK,cAAc,OAAO;AACpC,aAAO;AAAA,IACX;AACA,UAAM,QAAQ,MAAM,KAAK,UAAU;AACnC,QAAI,MAAM,OAAM;AACZ,aAAO;AACX,QAAI,MAAM,YAAW;AACjB,aAAO;AACX,QAAI,SAAS,MAAM,kBAAkB;AACjC,YAAM,OAAO,MAAM;AACnB,UAAI;AACA,cAAM,gBAAgB,MAAM,SAAS,IAAI;AACzC,cAAM,qBAAqB,MAAM,MAAM,aAAa;AACpD,YAAI,mBAAmB,UAAU;AAC7B,iBAAO;AAAA,QACX;AACA,YAAI,mBAAmB,eAAe;AAClC,gBAAM,MAAM,cAAc;AAC1B,cAAI,KAAK,WAAW,aAAa,KAAK,KAAK,OAAO,KAAK,CAAC,MAAMC,KAAM;AAChE,kBAAM,iBAAiB,IAAI,MAAM,+BAA+B,IAAI,gBAAgB,aAAa,GAAG;AAEpG,2BAAe,OAAO;AACtB,mBAAO,KAAK,SAAS,cAAc;AAAA,UACvC;AACA,iBAAO;AAAA,QACX;AAAA,MACJ,SACO,OAAO;AACV,aAAK,SAAS,KAAK;AACnB,eAAO;AAAA,MACX;AAAA,IACJ;AAAA,EACJ;AAAA,EACA,eAAe,OAAO;AAClB,UAAM,QAAQ,SAAS,MAAM,KAAK,UAAU;AAC5C,WAAO,SAAS,KAAK,oBAAoB,CAAC,MAAM,YAAW;AAAA,EAC/D;AACJ;AAOO,SAAS,SAAS,MAAM,UAAU,IAAI;AAEzC,MAAI,OAAO,QAAQ,aAAa,QAAQ;AACxC,MAAI,SAAS;AACT,WAAO,WAAW;AACtB,MAAI;AACA,YAAQ,OAAO;AACnB,MAAI,CAAC,MAAM;AACP,UAAM,IAAI,MAAM,qEAAqE;AAAA,EACzF,WACS,OAAO,SAAS,UAAU;AAC/B,UAAM,IAAI,UAAU,0EAA0E;AAAA,EAClG,WACS,QAAQ,CAAC,UAAU,SAAS,IAAI,GAAG;AACxC,UAAM,IAAI,MAAM,6CAA6C,UAAU,KAAK,IAAI,CAAC,EAAE;AAAA,EACvF;AACA,UAAQ,OAAO;AACf,SAAO,IAAI,eAAe,OAAO;AACrC;","x_google_ignoreList":[0]}

package/dist/esm/watchExternalSource.d.ts

@@ -0,0 +1,69 @@
+import { Plugin } from 'vite';
+export interface WatchExternalSourceOptions {
+    /**
+     * Name to display in console logs (e.g., '@igstack/app-catalog-frontend-core')
+     */
+    name: string;
+    /**
+     * Absolute path to the source directory to watch
+     */
+    srcPath: string;
+    /**
+     * Polling interval in ms (default: 500)
+     * Polling is required for cross-monorepo watching
+     */
+    interval?: number;
+}
+/**
+ * Creates a Vite plugin that watches an external source directory for changes
+ * and triggers HMR updates or full reloads.
+ *
+ * This is useful when developing with linked packages from another monorepo
+ * where Vite's default file watcher doesn't detect changes.
+ *
+ * @example
+ * ```ts
+ * // In vite.config.ts
+ * import { watchExternalSource } from '@igstack/app-catalog-frontend-build-vite'
+ * import path from 'node:path'
+ *
+ * export default defineConfig({
+ *   plugins: [
+ *     watchExternalSource({
+ *       name: '@igstack/app-catalog-frontend-core',
+ *       srcPath: path.resolve(__dirname, '../../../app-catalog/packages/frontend-core/src'),
+ *     }),
+ *   ],
+ * })
+ * ```
+ */
+export declare function watchExternalSource(options: WatchExternalSourceOptions): Plugin;
+/**
+ * Creates resolve aliases for pointing to source files instead of dist.
+ * Use this with watchExternalSource for full HMR support.
+ *
+ * @example
+ * ```ts
+ * // In vite.config.ts
+ * import { createSourceAliases } from '@igstack/app-catalog-frontend-build-vite'
+ * import path from 'node:path'
+ *
+ * const frontendCoreSrc = path.resolve(__dirname, '../../../app-catalog/packages/frontend-core/src')
+ *
+ * export default defineConfig({
+ *   resolve: {
+ *     alias: createSourceAliases({
+ *       '@igstack/app-catalog-frontend-core': `${frontendCoreSrc}/index.tsx`,
+ *       '~': frontendCoreSrc, // Internal path alias used by frontend-core
+ *     }),
+ *   },
+ * })
+ * ```
+ */
+export declare function createSourceAliases(aliases: Record<string, string>): Record<string, string>;
+/**
+ * Creates fs.allow paths for serving files from external directories.
+ *
+ * @param paths - Array of absolute paths to allow
+ */
+export declare function createFsAllowPaths(paths: Array<string>): Array<string>;

package/dist/esm/watchExternalSource.js

@@ -0,0 +1,85 @@
+function watchExternalSource(options) {
+  const { name, srcPath, interval = 500 } = options;
+  let watcher = null;
+  return {
+    name: `watch-external-source:${name}`,
+    configureServer(server) {
+      import("./node_modules/.pnpm/chokidar@5.0.0/node_modules/chokidar/index.js").then(({ watch }) => {
+        watcher = watch(srcPath, {
+          ignoreInitial: true,
+          usePolling: true,
+          // Required for cross-monorepo watching
+          interval
+        });
+        watcher.on("ready", () => {
+          console.log(`[HMR] Watching ${name} for changes`);
+        });
+        watcher.on("change", async (file) => {
+          var _a;
+          const shortPath = file.replace(srcPath, `${name}/src`);
+          console.log(`[HMR] ${shortPath} changed`);
+          let modules = server.moduleGraph.getModulesByFile(file);
+          if (!modules || modules.size === 0) {
+            const allModules = [...server.moduleGraph.idToModuleMap.values()];
+            const fileName = file.split("/").pop() || "";
+            const matchingModules = allModules.filter((mod) => {
+              if (!mod.file) return false;
+              return mod.file === file || mod.file.endsWith(fileName) || mod.url.includes(fileName);
+            });
+            if (matchingModules.length > 0) {
+              modules = new Set(matchingModules);
+            }
+          }
+          if (modules && modules.size > 0) {
+            const updates = [];
+            for (const mod of modules) {
+              server.moduleGraph.invalidateModule(mod);
+              const isCss = (_a = mod.file) == null ? void 0 : _a.endsWith(".css");
+              updates.push({
+                type: isCss ? "css-update" : "js-update",
+                path: mod.url,
+                acceptedPath: mod.url,
+                timestamp: Date.now()
+              });
+              console.log(`[HMR] Sending update for: ${mod.url}`);
+            }
+            if (updates.length > 0) {
+              server.ws.send({
+                type: "update",
+                updates
+              });
+              console.log(`[HMR] Sent ${updates.length} HMR update(s)`);
+              return;
+            }
+          }
+          console.log(`[HMR] Module not tracked, triggering full reload`);
+          server.moduleGraph.invalidateAll();
+          server.ws.send({
+            type: "full-reload",
+            path: "*"
+          });
+        });
+        watcher.on("error", (error) => {
+          console.error(`[HMR] Watcher error for ${name}:`, error);
+        });
+      });
+    },
+    closeBundle() {
+      if (watcher) {
+        watcher.close();
+      }
+    }
+  };
+}
+function createSourceAliases(aliases) {
+  return aliases;
+}
+function createFsAllowPaths(paths) {
+  return paths;
+}
+export {
+  createFsAllowPaths,
+  createSourceAliases,
+  watchExternalSource
+};
+//# sourceMappingURL=watchExternalSource.js.map

package/dist/esm/watchExternalSource.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"watchExternalSource.js","sources":["../../src/watchExternalSource.ts"],"sourcesContent":["import type { Plugin, ViteDevServer } from 'vite'\n\nexport interface WatchExternalSourceOptions {\n  /**\n   * Name to display in console logs (e.g., '@igstack/app-catalog-frontend-core')\n   */\n  name: string\n  /**\n   * Absolute path to the source directory to watch\n   */\n  srcPath: string\n  /**\n   * Polling interval in ms (default: 500)\n   * Polling is required for cross-monorepo watching\n   */\n  interval?: number\n}\n\n/**\n * Creates a Vite plugin that watches an external source directory for changes\n * and triggers HMR updates or full reloads.\n *\n * This is useful when developing with linked packages from another monorepo\n * where Vite's default file watcher doesn't detect changes.\n *\n * @example\n * ```ts\n * // In vite.config.ts\n * import { watchExternalSource } from '@igstack/app-catalog-frontend-build-vite'\n * import path from 'node:path'\n *\n * export default defineConfig({\n *   plugins: [\n *     watchExternalSource({\n *       name: '@igstack/app-catalog-frontend-core',\n *       srcPath: path.resolve(__dirname, '../../../app-catalog/packages/frontend-core/src'),\n *     }),\n *   ],\n * })\n * ```\n */\nexport function watchExternalSource(\n  options: WatchExternalSourceOptions,\n): Plugin {\n  const { name, srcPath, interval = 500 } = options\n  let watcher: import('chokidar').FSWatcher | null = null // eslint-disable-line @typescript-eslint/consistent-type-imports\n\n  return {\n    name: `watch-external-source:${name}`,\n    configureServer(server: ViteDevServer) {\n       \n      import('chokidar').then(({ watch }) => {\n        watcher = watch(srcPath, {\n          ignoreInitial: true,\n          usePolling: true, // Required for cross-monorepo watching\n          interval,\n        })\n\n        watcher.on('ready', () => {\n          console.log(`[HMR] Watching ${name} for changes`)\n        })\n\n        watcher.on('change', async (file: string) => {\n          const shortPath = file.replace(srcPath, `${name}/src`)\n          console.log(`[HMR] ${shortPath} changed`)\n\n          // Try multiple ways to find the module in Vite's graph\n          let modules = server.moduleGraph.getModulesByFile(file)\n\n          // If not found, try searching by URL patterns\n          if (!modules || modules.size === 0) {\n            const allModules = [...server.moduleGraph.idToModuleMap.values()]\n            const fileName = file.split('/').pop() || ''\n            const matchingModules = allModules.filter((mod) => {\n              if (!mod.file) return false\n              return (\n                mod.file === file ||\n                mod.file.endsWith(fileName) ||\n                mod.url.includes(fileName)\n              )\n            })\n            if (matchingModules.length > 0) {\n              modules = new Set(matchingModules)\n            }\n          }\n\n          if (modules && modules.size > 0) {\n            // Module is tracked - try true HMR\n            const updates: Array<{\n              type: 'js-update' | 'css-update'\n              path: string\n              acceptedPath: string\n              timestamp: number\n            }> = []\n\n            for (const mod of modules) {\n              server.moduleGraph.invalidateModule(mod)\n              const isCss = mod.file?.endsWith('.css')\n\n              updates.push({\n                type: isCss ? 'css-update' : 'js-update',\n                path: mod.url,\n                acceptedPath: mod.url,\n                timestamp: Date.now(),\n              })\n\n              console.log(`[HMR] Sending update for: ${mod.url}`)\n            }\n\n            if (updates.length > 0) {\n              server.ws.send({\n                type: 'update',\n                updates,\n              })\n              console.log(`[HMR] Sent ${updates.length} HMR update(s)`)\n              return\n            }\n          }\n\n          // Module not in graph - fall back to full reload\n          console.log(`[HMR] Module not tracked, triggering full reload`)\n          server.moduleGraph.invalidateAll()\n          server.ws.send({\n            type: 'full-reload',\n            path: '*',\n          })\n        })\n\n        watcher.on('error', (error: unknown) => {\n          console.error(`[HMR] Watcher error for ${name}:`, error)\n        })\n      })\n    },\n    closeBundle() {\n      if (watcher) {\n        watcher.close()\n      }\n    },\n  }\n}\n\n/**\n * Creates resolve aliases for pointing to source files instead of dist.\n * Use this with watchExternalSource for full HMR support.\n *\n * @example\n * ```ts\n * // In vite.config.ts\n * import { createSourceAliases } from '@igstack/app-catalog-frontend-build-vite'\n * import path from 'node:path'\n *\n * const frontendCoreSrc = path.resolve(__dirname, '../../../app-catalog/packages/frontend-core/src')\n *\n * export default defineConfig({\n *   resolve: {\n *     alias: createSourceAliases({\n *       '@igstack/app-catalog-frontend-core': `${frontendCoreSrc}/index.tsx`,\n *       '~': frontendCoreSrc, // Internal path alias used by frontend-core\n *     }),\n *   },\n * })\n * ```\n */\nexport function createSourceAliases(\n  aliases: Record<string, string>,\n): Record<string, string> {\n  return aliases\n}\n\n/**\n * Creates fs.allow paths for serving files from external directories.\n *\n * @param paths - Array of absolute paths to allow\n */\nexport function createFsAllowPaths(paths: Array<string>): Array<string> {\n  return paths\n}\n"],"names":[],"mappings":"AAyCO,SAAS,oBACd,SACQ;AACR,QAAM,EAAE,MAAM,SAAS,WAAW,QAAQ;AAC1C,MAAI,UAA+C;AAEnD,SAAO;AAAA,IACL,MAAM,yBAAyB,IAAI;AAAA,IACnC,gBAAgB,QAAuB;AAErC,aAAO,oEAAU,EAAE,KAAK,CAAC,EAAE,YAAY;AACrC,kBAAU,MAAM,SAAS;AAAA,UACvB,eAAe;AAAA,UACf,YAAY;AAAA;AAAA,UACZ;AAAA,QAAA,CACD;AAED,gBAAQ,GAAG,SAAS,MAAM;AACxB,kBAAQ,IAAI,kBAAkB,IAAI,cAAc;AAAA,QAClD,CAAC;AAED,gBAAQ,GAAG,UAAU,OAAO,SAAiB;AArB9C;AAsBG,gBAAM,YAAY,KAAK,QAAQ,SAAS,GAAG,IAAI,MAAM;AACrD,kBAAQ,IAAI,SAAS,SAAS,UAAU;AAGxC,cAAI,UAAU,OAAO,YAAY,iBAAiB,IAAI;AAGtD,cAAI,CAAC,WAAW,QAAQ,SAAS,GAAG;AAClC,kBAAM,aAAa,CAAC,GAAG,OAAO,YAAY,cAAc,QAAQ;AAChE,kBAAM,WAAW,KAAK,MAAM,GAAG,EAAE,SAAS;AAC1C,kBAAM,kBAAkB,WAAW,OAAO,CAAC,QAAQ;AACjD,kBAAI,CAAC,IAAI,KAAM,QAAO;AACtB,qBACE,IAAI,SAAS,QACb,IAAI,KAAK,SAAS,QAAQ,KAC1B,IAAI,IAAI,SAAS,QAAQ;AAAA,YAE7B,CAAC;AACD,gBAAI,gBAAgB,SAAS,GAAG;AAC9B,wBAAU,IAAI,IAAI,eAAe;AAAA,YACnC;AAAA,UACF;AAEA,cAAI,WAAW,QAAQ,OAAO,GAAG;AAE/B,kBAAM,UAKD,CAAA;AAEL,uBAAW,OAAO,SAAS;AACzB,qBAAO,YAAY,iBAAiB,GAAG;AACvC,oBAAM,SAAQ,SAAI,SAAJ,mBAAU,SAAS;AAEjC,sBAAQ,KAAK;AAAA,gBACX,MAAM,QAAQ,eAAe;AAAA,gBAC7B,MAAM,IAAI;AAAA,gBACV,cAAc,IAAI;AAAA,gBAClB,WAAW,KAAK,IAAA;AAAA,cAAI,CACrB;AAED,sBAAQ,IAAI,6BAA6B,IAAI,GAAG,EAAE;AAAA,YACpD;AAEA,gBAAI,QAAQ,SAAS,GAAG;AACtB,qBAAO,GAAG,KAAK;AAAA,gBACb,MAAM;AAAA,gBACN;AAAA,cAAA,CACD;AACD,sBAAQ,IAAI,cAAc,QAAQ,MAAM,gBAAgB;AACxD;AAAA,YACF;AAAA,UACF;AAGA,kBAAQ,IAAI,kDAAkD;AAC9D,iBAAO,YAAY,cAAA;AACnB,iBAAO,GAAG,KAAK;AAAA,YACb,MAAM;AAAA,YACN,MAAM;AAAA,UAAA,CACP;AAAA,QACH,CAAC;AAED,gBAAQ,GAAG,SAAS,CAAC,UAAmB;AACtC,kBAAQ,MAAM,2BAA2B,IAAI,KAAK,KAAK;AAAA,QACzD,CAAC;AAAA,MACH,CAAC;AAAA,IACH;AAAA,IACA,cAAc;AACZ,UAAI,SAAS;AACX,gBAAQ,MAAA;AAAA,MACV;AAAA,IACF;AAAA,EAAA;AAEJ;AAwBO,SAAS,oBACd,SACwB;AACxB,SAAO;AACT;AAOO,SAAS,mBAAmB,OAAqC;AACtE,SAAO;AACT;"}

package/package.json

@@ -0,0 +1,64 @@
+{
+  "name": "@igstack/app-catalog-frontend-build-vite",
+  "version": "0.0.1",
+  "description": "Vite build config for App Catalog frontend",
+  "homepage": "https://github.com/lislon/app-catalog",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/lislon/app-catalog.git",
+    "directory": "packages/frontend-build-vite"
+  },
+  "license": "MIT",
+  "author": "Igor Golovin",
+  "sideEffects": false,
+  "type": "module",
+  "exports": {
+    ".": {
+      "my-custom-condition": "./src/index.ts",
+      "import": {
+        "types": "./dist/esm/index.d.ts",
+        "default": "./dist/esm/index.js"
+      }
+    },
+    "./package.json": "./package.json"
+  },
+  "module": "dist/esm/index.js",
+  "types": "dist/esm/index.d.ts",
+  "files": [
+    "dist",
+    "src"
+  ],
+  "dependencies": {
+    "@tailwindcss/vite": "^4.0.5",
+    "@tanstack/react-router-devtools": "^1.151.6",
+    "@tanstack/router-plugin": "^1.151.6",
+    "@vitejs/plugin-react": "^4.3.4",
+    "vite-plugin-pwa": "^1.0.0",
+    "vite-plugin-static-copy": "^3.1.4",
+    "vite-plugin-svgr": "^4.2.0"
+  },
+  "devDependencies": {
+    "@tanstack/vite-config": "^0.4.3",
+    "@types/node": "^24.3.0",
+    "chokidar": "^5.0.0",
+    "esbuild": "^0.25.5",
+    "tsx": "^4.19.4",
+    "typescript": "5.9.2",
+    "vite": "^6.3.5",
+    "@igstack/app-catalog-shared-core": "0.0.1"
+  },
+  "peerDependencies": {
+    "vite": "^6.3.5",
+    "vite-plugin-svgr": "^4.2.0"
+  },
+  "engines": {
+    "node": ">=16"
+  },
+  "scripts": {
+    "build": "vite build",
+    "build:lenient": "vite build --mode lenient",
+    "clean": "premove ./dist ./coverage ./dist-ts",
+    "compile": "tsc --build",
+    "test:eslint": "eslint ./src"
+  }
+}