svelte-ag 1.1.0 → 1.1.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "svelte-ag",
-  "version": "1.1.0",
+  "version": "1.1.1",
   "description": "Useful svelte components",
   "bugs": "https://github.com/ageorgeh/svelte-ag/issues",
   "repository": {
@@ -19,9 +19,6 @@
     "./styles/*": "./dist/styles/*",
     "./package.json": "./package.json"
   },
-  "bin": {
-    "resolve-paths": "dist/scripts/resolve-paths/index.js"
-  },
   "files": [
     "./src/lib",
     "./dist"
@@ -46,7 +43,7 @@
   "dependencies": {
     "@dnd-kit-svelte/svelte": "^0.1.6",
     "@floating-ui/dom": "^1.7.6",
-    "bits-ui": "^2.16.5",
+    "bits-ui": "^2.17.2",
     "clsx": "^2.1.1",
     "dequal": "^2.0.3",
     "devalue": "^5.6.4",
@@ -65,7 +62,7 @@
   "devDependencies": {
     "@actions/languageserver": "^0.3.51",
     "@eslint/js": "^10.0.1",
-    "@iconify/json": "^2.2.458",
+    "@iconify/json": "^2.2.459",
     "@iconify/tailwind4": "^1.2.3",
     "@iconify/types": "^2.0.0",
     "@internationalized/date": "^3.12.0",
@@ -88,14 +85,14 @@
     "prettier": "^3.8.1",
     "prettier-plugin-packagejson": "^3.0.1",
     "prettier-plugin-svelte": "^3.5.1",
-    "rolldown": "1.0.0-rc.12",
+    "rolldown": "1.0.0-rc.13",
     "rolldown-plugin-dts": "^0.23.2",
     "rollup-plugin-svelte": "^7.2.3",
     "semantic-release": "^25.0.3",
     "svelte": "^5.55.1",
     "svelte-check": "^4.4.6",
     "svelte-preprocess": "^6.0.3",
-    "svelte2tsx": "^0.7.52",
+    "svelte2tsx": "^0.7.53",
     "tailwindcss": "4.2.2",
     "tsdown": "^0.21.7",
     "tsx": "^4.21.0",

package/dist/scripts/resolve-paths/index.d.ts

@@ -1,31 +0,0 @@
-//#region dist/scripts/resolve-paths/index.d.ts
-interface ResolvePathsProject {
-  tsconfigPath: string;
-  rootDir: string;
-  srcDir: string;
-  distDir: string;
-}
-interface ResolvePathsOptions {
-  cwd?: string;
-  excludeAliases?: string[];
-  inputs?: string[];
-}
-interface ResolvePathsWatcher {
-  close(): void;
-  projects: ResolvePathsProject[];
-}
-interface CliOptions {
-  excludeAliases: string[];
-  inputs: string[];
-  watchMode: boolean;
-}
-declare function buildProject(project: ResolvePathsProject, options?: ResolvePathsOptions): Promise<void>;
-declare function findProjects(options?: ResolvePathsOptions): Promise<ResolvePathsProject[]>;
-declare function buildProjects(options?: ResolvePathsOptions): Promise<ResolvePathsProject[]>;
-declare function watchProjects(options?: ResolvePathsOptions): Promise<ResolvePathsWatcher>;
-declare function parseCliArgs(args: string[]): CliOptions;
-declare function isDirectExecution(entryPath?: string, moduleUrl?: string): boolean;
-declare function main(args?: string[]): Promise<void>;
-//#endregion
-export { ResolvePathsOptions, ResolvePathsProject, ResolvePathsWatcher, buildProject, buildProjects, findProjects, isDirectExecution, main, parseCliArgs, watchProjects };
-//# sourceMappingURL=index.d.ts.map

package/dist/scripts/resolve-paths/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","names":["ResolvePathsProject","tsconfigPath","rootDir","srcDir","distDir","ResolvePathsOptions","cwd","excludeAliases","inputs","ResolvePathsWatcher","close","projects","CliOptions","watchMode","buildProject","Promise","project","options","findProjects","buildProjects","watchProjects","parseCliArgs","args","isDirectExecution","entryPath","moduleUrl","main"],"sources":["../../home/runner/work/svelte-ag/svelte-ag/dist/scripts/resolve-paths/index.d.ts"],"mappings":";UAAiBA,mBAAAA;EACbC,YAAAA;EACAC,OAAAA;EACAC,MAAAA;EACAC,OAAAA;AAAAA;AAAAA,UAEaC,mBAAAA;EACbC,GAAAA;EACAC,cAAAA;EACAC,MAAAA;AAAAA;AAAAA,UAEaC,mBAAAA;EACbC,KAAAA;EACAC,QAAAA,EAAUX,mBAAAA;AAAAA;AAAAA,UAEJY,UAAAA;EACNL,cAAAA;EACAC,MAAAA;EACAK,SAAAA;AAAAA;AAAAA,iBAEoBC,YAAAA,CAAaE,OAAAA,EAAShB,mBAAAA,EAAqBiB,OAAAA,GAAUZ,mBAAAA,GAAsBU,OAAAA;AAAAA,iBAC3EG,YAAAA,CAAaD,OAAAA,GAAUZ,mBAAAA,GAAsBU,OAAAA,CAAQf,mBAAAA;AAAAA,iBACrDmB,aAAAA,CAAcF,OAAAA,GAAUZ,mBAAAA,GAAsBU,OAAAA,CAAQf,mBAAAA;AAAAA,iBACtDoB,aAAAA,CAAcH,OAAAA,GAAUZ,mBAAAA,GAAsBU,OAAAA,CAAQN,mBAAAA;AAAAA,iBACtDY,YAAAA,CAAaC,IAAAA,aAAiBV,UAAAA;AAAAA,iBAC9BW,iBAAAA,CAAkBC,SAAAA,WAAoBC,SAAAA;AAAAA,iBACtCC,IAAAA,CAAKJ,IAAAA,cAAkBP,OAAAA"}

package/dist/scripts/resolve-paths/index.js

@@ -1,549 +0,0 @@
-import { cp, glob, mkdir, readFile, readdir, rename, rm, stat, writeFile } from 'node:fs/promises';
-import { realpathSync, watch } from 'node:fs';
-import { basename, dirname, isAbsolute, join, relative, resolve } from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { prepareSingleFileReplaceTscAliasPaths, replaceTscAliasPaths } from 'tsc-alias';
-import { loadConfig, prepareConfig } from 'tsc-alias/dist/helpers/config.js';
-import { Output, TrieNode } from 'tsc-alias/dist/utils/index.js';
-import { exists } from 'ts-ag';
-import { logError, logInfo } from './log.js';
-const DEFAULT_INPUTS = ['tsconfig.json'];
-const GLOB_EXCLUDES = ['**/node_modules/**', '**/.git/**', '**/.svelte-kit/**', '**/dist/**'];
-const TEMPORARY_WATCH_FILE_SUFFIXES = ['~', '.swp', '.swo', '.tmp', '.temp', '.bak', '.orig'];
-const REPLACEABLE_FILE_EXTENSIONS = {
-    inputGlob: '{ts,tsx,js,jsx,mjs,cjs,svelte,d.{mts,cts,ts,tsx}}',
-    outputCheck: [
-        'ts',
-        'tsx',
-        'js',
-        'jsx',
-        'mjs',
-        'cjs',
-        'svelte',
-        'json',
-        'mts',
-        'cts',
-        'd.ts',
-        'd.tsx',
-        'd.mts',
-        'd.cts'
-    ]
-};
-function formatPath(targetPath, cwd = process.cwd()) {
-    return relative(cwd, targetPath) || '.';
-}
-function normalizeWatchPathSeparators(filePath) {
-    return filePath.replaceAll('\\', '/');
-}
-function isTemporaryWatchPath(sourceRelativePath) {
-    const normalizedSourceRelativePath = normalizeWatchPathSeparators(sourceRelativePath);
-    const fileName = basename(normalizedSourceRelativePath);
-    return (TEMPORARY_WATCH_FILE_SUFFIXES.some((suffix) => fileName.endsWith(suffix)) ||
-        fileName.startsWith('.#') ||
-        (fileName.startsWith('#') && fileName.endsWith('#')));
-}
-function getCanonicalWatchPathCandidates(sourceRelativePath) {
-    const normalizedSourceRelativePath = normalizeWatchPathSeparators(sourceRelativePath);
-    const fileName = basename(normalizedSourceRelativePath);
-    const parentDirectory = dirname(normalizedSourceRelativePath);
-    const parentPrefix = parentDirectory === '.' ? '' : `${parentDirectory}/`;
-    const canonicalFileNames = new Set();
-    if (fileName.endsWith('~') && fileName.length > 1) {
-        canonicalFileNames.add(fileName.slice(0, -1));
-    }
-    for (const suffix of TEMPORARY_WATCH_FILE_SUFFIXES.filter((value) => value !== '~')) {
-        if (fileName.endsWith(suffix) && fileName.length > suffix.length) {
-            canonicalFileNames.add(fileName.slice(0, -suffix.length));
-        }
-    }
-    if (fileName.startsWith('.#') && fileName.length > 2) {
-        canonicalFileNames.add(fileName.slice(2));
-    }
-    if (fileName.startsWith('#') && fileName.endsWith('#') && fileName.length > 2) {
-        canonicalFileNames.add(fileName.slice(1, -1));
-    }
-    return [...canonicalFileNames].map((candidate) => `${parentPrefix}${candidate}`);
-}
-async function resolveWatchedSourcePath(project, sourceRelativePath) {
-    const normalizedSourceRelativePath = normalizeWatchPathSeparators(sourceRelativePath);
-    const temporaryPath = isTemporaryWatchPath(normalizedSourceRelativePath);
-    const candidates = temporaryPath
-        ? [...getCanonicalWatchPathCandidates(normalizedSourceRelativePath), normalizedSourceRelativePath]
-        : [normalizedSourceRelativePath, ...getCanonicalWatchPathCandidates(normalizedSourceRelativePath)];
-    for (const candidate of [...new Set(candidates)]) {
-        const sourcePath = resolve(project.srcDir, candidate);
-        const normalizedRelativePath = relative(project.srcDir, sourcePath);
-        if (normalizedRelativePath.startsWith('..') || isAbsolute(normalizedRelativePath)) {
-            continue;
-        }
-        if (await exists(sourcePath)) {
-            return normalizeWatchPathSeparators(normalizedRelativePath);
-        }
-    }
-    return temporaryPath ? undefined : normalizedSourceRelativePath;
-}
-async function resolveDirectInput(input, cwd) {
-    const absoluteInputPath = isAbsolute(input) ? input : resolve(cwd, input);
-    if (!(await exists(absoluteInputPath))) {
-        return [];
-    }
-    const inputStats = await stat(absoluteInputPath);
-    if (inputStats.isDirectory()) {
-        const nestedTsconfigPath = resolve(absoluteInputPath, 'tsconfig.json');
-        return (await exists(nestedTsconfigPath)) ? [nestedTsconfigPath] : [];
-    }
-    return [absoluteInputPath];
-}
-async function expandInput(input, cwd) {
-    const directMatches = await resolveDirectInput(input, cwd);
-    if (directMatches.length > 0) {
-        return directMatches;
-    }
-    const matches = await Array.fromAsync(glob(input, {
-        cwd,
-        exclude: GLOB_EXCLUDES
-    }));
-    return matches.map((match) => resolve(cwd, match));
-}
-function normalizeAliasPrefix(alias) {
-    return alias.replace(/\/\*$/, '').replace(/\/+$/, '');
-}
-function normalizeExcludedAliases(excludedAliases = []) {
-    return [...new Set(excludedAliases.map(normalizeAliasPrefix).filter(Boolean))];
-}
-function createTemporaryPath(rootDir, prefix) {
-    return resolve(rootDir, `.${prefix}-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}.tmp`);
-}
-function createSilentOutput() {
-    return new Output(false, false);
-}
-async function createFilteredAliasTrie(project, excludedAliases, outDir) {
-    if (excludedAliases.length === 0) {
-        return undefined;
-    }
-    const normalizedExcludedAliases = new Set(excludedAliases.map(normalizeAliasPrefix).filter(Boolean));
-    const output = createSilentOutput();
-    const loadedConfig = loadConfig(project.tsconfigPath, output);
-    if (!loadedConfig.paths) {
-        return undefined;
-    }
-    const filteredPaths = Object.fromEntries(Object.entries(loadedConfig.paths).filter(([alias]) => !normalizedExcludedAliases.has(normalizeAliasPrefix(alias))));
-    const preparedConfig = await prepareConfig({
-        configFile: project.tsconfigPath,
-        fileExtensions: {
-            inputGlob: REPLACEABLE_FILE_EXTENSIONS.inputGlob,
-            outputCheck: [...REPLACEABLE_FILE_EXTENSIONS.outputCheck]
-        },
-        outDir,
-        output
-    });
-    return TrieNode.buildAliasTrie(preparedConfig, filteredPaths);
-}
-function isReplaceableOutputFile(filePath) {
-    const normalizedFilePath = filePath.toLowerCase();
-    return REPLACEABLE_FILE_EXTENSIONS.outputCheck.some((extension) => normalizedFilePath.endsWith(`.${extension.toLowerCase()}`));
-}
-async function createSingleFileAliasReplacer(project, excludedAliases) {
-    return prepareSingleFileReplaceTscAliasPaths({
-        aliasTrie: await createFilteredAliasTrie(project, excludedAliases, project.distDir),
-        configFile: project.tsconfigPath,
-        outDir: project.distDir,
-        fileExtensions: {
-            inputGlob: REPLACEABLE_FILE_EXTENSIONS.inputGlob,
-            outputCheck: [...REPLACEABLE_FILE_EXTENSIONS.outputCheck]
-        }
-    });
-}
-async function resolveAliases(project, outDir, options = {}) {
-    await replaceTscAliasPaths({
-        aliasTrie: await createFilteredAliasTrie(project, options.excludeAliases ?? [], outDir),
-        configFile: project.tsconfigPath,
-        outDir,
-        fileExtensions: {
-            inputGlob: REPLACEABLE_FILE_EXTENSIONS.inputGlob,
-            outputCheck: [...REPLACEABLE_FILE_EXTENSIONS.outputCheck]
-        }
-    });
-}
-async function copyProjectSource(project, outDir) {
-    await rm(outDir, {
-        force: true,
-        recursive: true
-    });
-    await mkdir(dirname(outDir), { recursive: true });
-    await cp(project.srcDir, outDir, {
-        force: true,
-        recursive: true
-    });
-}
-async function collectProjectTree(rootDir, currentDir = rootDir) {
-    if (!(await exists(currentDir))) {
-        return [];
-    }
-    const entries = await readdir(currentDir, { withFileTypes: true });
-    const paths = [];
-    for (const entry of entries) {
-        const entryPath = join(currentDir, entry.name);
-        const relativePath = relative(rootDir, entryPath);
-        paths.push(relativePath);
-        if (entry.isDirectory()) {
-            paths.push(...(await collectProjectTree(rootDir, entryPath)));
-        }
-    }
-    return paths;
-}
-async function publishStagedProject(stageDir, distDir) {
-    const stagedPaths = await collectProjectTree(stageDir);
-    const stagedPathSet = new Set(stagedPaths);
-    for (const relativePath of stagedPaths
-        .filter((path) => path !== '')
-        .sort((left, right) => left.localeCompare(right))) {
-        const stagedPath = resolve(stageDir, relativePath);
-        const distPath = resolve(distDir, relativePath);
-        const stagedStats = await stat(stagedPath);
-        if (stagedStats.isDirectory()) {
-            await mkdir(distPath, { recursive: true });
-            continue;
-        }
-        await mkdir(dirname(distPath), { recursive: true });
-        await rename(stagedPath, distPath);
-    }
-    if (!(await exists(distDir))) {
-        return;
-    }
-    const distPaths = await collectProjectTree(distDir);
-    for (const relativePath of distPaths.sort((left, right) => right.length - left.length || right.localeCompare(left))) {
-        if (!stagedPathSet.has(relativePath)) {
-            await rm(resolve(distDir, relativePath), {
-                force: true,
-                recursive: true
-            });
-        }
-    }
-}
-async function resolveFileContents(project, distPath, sourceContents, excludedAliases) {
-    if (!isReplaceableOutputFile(distPath)) {
-        return sourceContents;
-    }
-    const resolveAliasesInFile = await createSingleFileAliasReplacer(project, excludedAliases);
-    return resolveAliasesInFile({
-        fileContents: sourceContents,
-        filePath: distPath
-    });
-}
-async function publishFileAtomically(project, sourcePath, distPath, excludedAliases) {
-    const tempPath = createTemporaryPath(dirname(distPath), basename(distPath));
-    await mkdir(dirname(distPath), { recursive: true });
-    if (isReplaceableOutputFile(distPath)) {
-        const sourceContents = await readFile(sourcePath, 'utf8');
-        const resolvedContents = await resolveFileContents(project, distPath, sourceContents, excludedAliases);
-        await writeFile(tempPath, resolvedContents, 'utf8');
-    }
-    else {
-        await cp(sourcePath, tempPath, { force: true });
-    }
-    await rename(tempPath, distPath);
-}
-async function syncProjectSourcePath(project, sourceRelativePath, excludedAliases) {
-    const sourcePath = resolve(project.srcDir, sourceRelativePath);
-    const normalizedRelativePath = relative(project.srcDir, sourcePath);
-    if (normalizedRelativePath.startsWith('..') || isAbsolute(normalizedRelativePath)) {
-        await buildProject(project, {
-            excludeAliases: excludedAliases
-        });
-        return 'rebuilt';
-    }
-    const distPath = resolve(project.distDir, normalizedRelativePath);
-    if (!(await exists(sourcePath))) {
-        await rm(distPath, {
-            force: true,
-            recursive: true
-        });
-        return 'synced';
-    }
-    const sourceStats = await stat(sourcePath);
-    if (!sourceStats.isFile()) {
-        await buildProject(project, {
-            excludeAliases: excludedAliases
-        });
-        return 'rebuilt';
-    }
-    await publishFileAtomically(project, sourcePath, distPath, excludedAliases);
-    return 'synced';
-}
-export async function buildProject(project, options = {}) {
-    const excludedAliases = normalizeExcludedAliases(options.excludeAliases);
-    const stageDir = createTemporaryPath(project.rootDir, basename(project.distDir));
-    try {
-        await copyProjectSource(project, stageDir);
-        await resolveAliases(project, stageDir, {
-            ...options,
-            excludeAliases: excludedAliases
-        });
-        await publishStagedProject(stageDir, project.distDir);
-    }
-    finally {
-        await rm(stageDir, {
-            force: true,
-            recursive: true
-        });
-    }
-}
-export async function findProjects(options = {}) {
-    const cwd = options.cwd ?? process.cwd();
-    const inputs = options.inputs && options.inputs.length > 0 ? options.inputs : DEFAULT_INPUTS;
-    const resolvedTsconfigPaths = new Set();
-    for (const input of inputs) {
-        const matches = await expandInput(input, cwd);
-        if (matches.length === 0) {
-            throw new Error(`No tsconfig.json files matched "${input}" from ${formatPath(cwd, cwd)}`);
-        }
-        for (const match of matches) {
-            if (basename(match) !== 'tsconfig.json') {
-                continue;
-            }
-            resolvedTsconfigPaths.add(resolve(match));
-        }
-    }
-    const projects = await Promise.all([...resolvedTsconfigPaths]
-        .sort((left, right) => left.localeCompare(right))
-        .map(async (tsconfigPath) => {
-        const rootDir = dirname(tsconfigPath);
-        const srcDir = resolve(rootDir, 'src');
-        if (!(await exists(srcDir))) {
-            throw new Error(`Missing src directory for ${formatPath(tsconfigPath, cwd)} at ${formatPath(srcDir, cwd)}`);
-        }
-        return {
-            distDir: resolve(rootDir, 'dist'),
-            rootDir,
-            srcDir,
-            tsconfigPath
-        };
-    }));
-    if (projects.length === 0) {
-        throw new Error(`No tsconfig.json files matched: ${inputs.join(', ')}`);
-    }
-    return projects;
-}
-export async function buildProjects(options = {}) {
-    const cwd = options.cwd ?? process.cwd();
-    const projects = await findProjects(options);
-    await Promise.all(projects.map(async (project) => {
-        await buildProject(project, options);
-        logInfo(`updated ${formatPath(project.distDir, cwd)} from ${formatPath(project.srcDir, cwd)} using ${formatPath(project.tsconfigPath, cwd)}`);
-    }));
-    return projects;
-}
-function createDebouncedProjectRunner(project, cwd, options) {
-    let closed = false;
-    let activeBuild;
-    let pendingReason;
-    let pendingFullRebuild = false;
-    let pendingSourcePaths = new Set();
-    let timer;
-    const excludedAliases = normalizeExcludedAliases(options.excludeAliases);
-    const run = async () => {
-        if (closed) {
-            return;
-        }
-        if (activeBuild) {
-            return;
-        }
-        const reason = pendingReason ?? 'change';
-        const fullRebuild = pendingFullRebuild;
-        const sourcePaths = fullRebuild ? [] : [...pendingSourcePaths].sort((left, right) => left.localeCompare(right));
-        pendingReason = undefined;
-        pendingFullRebuild = false;
-        pendingSourcePaths = new Set();
-        activeBuild = (async () => {
-            if (fullRebuild || sourcePaths.length === 0) {
-                logInfo(`rebuilding ${formatPath(project.tsconfigPath, cwd)} after ${reason}`);
-                await buildProject(project, {
-                    ...options,
-                    excludeAliases: excludedAliases
-                });
-                logInfo(`watch updated ${formatPath(project.distDir, cwd)}`);
-                return;
-            }
-            const resolvedSourcePaths = new Set();
-            for (const sourcePath of sourcePaths) {
-                const resolvedSourcePath = await resolveWatchedSourcePath(project, sourcePath);
-                if (resolvedSourcePath) {
-                    resolvedSourcePaths.add(resolvedSourcePath);
-                }
-            }
-            if (resolvedSourcePaths.size === 0) {
-                logInfo(`ignoring temporary watch path(s) in ${formatPath(project.tsconfigPath, cwd)} after ${reason}`);
-                return;
-            }
-            logInfo(`updating ${resolvedSourcePaths.size} changed path(s) in ${formatPath(project.tsconfigPath, cwd)} after ${reason}`);
-            for (const sourcePath of [...resolvedSourcePaths].sort((left, right) => left.localeCompare(right))) {
-                const result = await syncProjectSourcePath(project, sourcePath, excludedAliases);
-                if (result === 'rebuilt') {
-                    logInfo(`watch updated ${formatPath(project.distDir, cwd)}`);
-                    return;
-                }
-            }
-            logInfo(`watch updated ${formatPath(project.distDir, cwd)}`);
-        })();
-        try {
-            await activeBuild;
-        }
-        finally {
-            activeBuild = undefined;
-            if (pendingReason) {
-                await run();
-            }
-        }
-    };
-    return {
-        close() {
-            closed = true;
-            if (timer) {
-                clearTimeout(timer);
-                timer = undefined;
-            }
-        },
-        schedule(reason, sourceRelativePath) {
-            if (closed) {
-                return;
-            }
-            pendingReason = reason;
-            if (sourceRelativePath) {
-                if (!pendingFullRebuild) {
-                    pendingSourcePaths.add(sourceRelativePath);
-                }
-            }
-            else {
-                pendingFullRebuild = true;
-                pendingSourcePaths.clear();
-            }
-            if (timer) {
-                clearTimeout(timer);
-            }
-            timer = setTimeout(() => {
-                timer = undefined;
-                void run().catch((error) => {
-                    logError(`watch rebuild failed for ${formatPath(project.tsconfigPath, cwd)}: ${error.message}`);
-                });
-            }, 100);
-        }
-    };
-}
-function watchProject(project, cwd, options) {
-    const runner = createDebouncedProjectRunner(project, cwd, options);
-    const sourceWatcher = watch(project.srcDir, { recursive: true }, (_eventType, fileName) => {
-        runner.schedule('src change', fileName?.toString());
-    });
-    const configWatcher = watch(project.tsconfigPath, () => {
-        runner.schedule('tsconfig change');
-    });
-    return [
-        sourceWatcher,
-        configWatcher,
-        {
-            close() {
-                runner.close();
-            }
-        }
-    ];
-}
-export async function watchProjects(options = {}) {
-    const cwd = options.cwd ?? process.cwd();
-    const projects = await buildProjects(options);
-    const watchers = projects.flatMap((project) => watchProject(project, cwd, options));
-    logInfo(`watching ${projects.length} project(s)`);
-    return {
-        close() {
-            for (const watcher of watchers) {
-                watcher.close();
-            }
-        },
-        projects
-    };
-}
-export function parseCliArgs(args) {
-    const excludeAliases = [];
-    const inputs = [];
-    let watchMode = false;
-    for (let index = 0; index < args.length; index += 1) {
-        const arg = args[index];
-        if (arg === '-w' || arg === '--watch') {
-            watchMode = true;
-            continue;
-        }
-        if (arg === '--exclude-alias') {
-            const value = args[index + 1];
-            if (!value || value.startsWith('-')) {
-                throw new Error('Missing value for --exclude-alias');
-            }
-            excludeAliases.push(...value
-                .split(',')
-                .map((item) => item.trim())
-                .filter(Boolean));
-            index += 1;
-            continue;
-        }
-        if (arg.startsWith('--exclude-alias=')) {
-            excludeAliases.push(...arg
-                .slice('--exclude-alias='.length)
-                .split(',')
-                .map((item) => item.trim())
-                .filter(Boolean));
-            continue;
-        }
-        if (arg === '-h' || arg === '--help') {
-            printUsage();
-            process.exit(0);
-        }
-        if (arg.startsWith('-')) {
-            throw new Error(`Unknown option "${arg}"`);
-        }
-        inputs.push(arg);
-    }
-    return {
-        excludeAliases,
-        inputs,
-        watchMode
-    };
-}
-function printUsage() {
-    console.log([
-        'Usage: resolve-paths [--watch] [tsconfig.json path or glob ...]',
-        '',
-        'Examples:',
-        '  resolve-paths',
-        '  resolve-paths tsconfig.json',
-        "  resolve-paths --exclude-alias '$shared,$generated' tsconfig.json",
-        "  resolve-paths 'packages/*/tsconfig.json'",
-        "  resolve-paths --watch 'packages/*/tsconfig.json'"
-    ].join('\n'));
-}
-function normalizeExecutablePath(targetPath) {
-    try {
-        return realpathSync.native(targetPath);
-    }
-    catch {
-        return resolve(targetPath);
-    }
-}
-export function isDirectExecution(entryPath = process.argv[1], moduleUrl = import.meta.url) {
-    if (!entryPath) {
-        return false;
-    }
-    return normalizeExecutablePath(entryPath) === normalizeExecutablePath(fileURLToPath(moduleUrl));
-}
-export async function main(args = process.argv.slice(2)) {
-    const { excludeAliases, inputs, watchMode } = parseCliArgs(args);
-    if (watchMode) {
-        await watchProjects({ excludeAliases, inputs });
-        return;
-    }
-    await buildProjects({ excludeAliases, inputs });
-}
-if (isDirectExecution()) {
-    void main().catch((error) => {
-        logError(error.message);
-        process.exit(1);
-    });
-}

package/dist/scripts/resolve-paths/log.d.ts

@@ -1,4 +0,0 @@
-export declare function time(): string;
-export declare function logInfo(message: string): void;
-export declare function logError(message: string): void;
-//# sourceMappingURL=log.d.ts.map

package/dist/scripts/resolve-paths/log.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"log.d.ts","sourceRoot":"","sources":["../../../src/lib/scripts/resolve-paths/log.ts"],"names":[],"mappings":"AAIA,wBAAgB,IAAI,WAanB;AAED,wBAAgB,OAAO,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAE7C;AAED,wBAAgB,QAAQ,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAE9C"}

package/dist/scripts/resolve-paths/log.js

@@ -1,18 +0,0 @@
-import { styleText } from 'util';
-const LABEL = '[resolve-paths]';
-export function time() {
-    const now = new Date();
-    let hours = now.getHours();
-    const minutes = now.getMinutes();
-    const seconds = now.getSeconds();
-    const ampm = hours >= 12 ? 'PM' : 'AM';
-    hours = hours % 12 || 12;
-    const pad = (n) => n.toString().padStart(2, '0');
-    return styleText('grey', `[${pad(hours)}:${pad(minutes)}:${pad(seconds)} ${ampm}]`);
-}
-export function logInfo(message) {
-    console.log(`${LABEL} ${time()} ${message}`);
-}
-export function logError(message) {
-    console.error(`${LABEL} ${time()} ${message}`);
-}

package/dist/scripts/resolve-paths/resolve-paths.unit.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=resolve-paths.unit.test.d.ts.map

package/dist/scripts/resolve-paths/resolve-paths.unit.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"resolve-paths.unit.test.d.ts","sourceRoot":"","sources":["../../../src/lib/scripts/resolve-paths/resolve-paths.unit.test.ts"],"names":[],"mappings":""}