svelte-ag 1.0.67 → 1.0.68

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"resolve-paths.d.ts","sourceRoot":"","sources":["../../src/lib/scripts/resolve-paths.ts"],"names":[],"mappings":"AAgCA,MAAM,WAAW,mBAAmB;IAClC,YAAY,EAAE,MAAM,CAAC;IACrB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,mBAAmB;IAClC,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,cAAc,CAAC,EAAE,MAAM,EAAE,CAAC;IAC1B,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;CACnB;AAED,MAAM,WAAW,mBAAmB;IAClC,KAAK,IAAI,IAAI,CAAC;IACd,QAAQ,EAAE,mBAAmB,EAAE,CAAC;CACjC;AAED,UAAU,UAAU;IAClB,cAAc,EAAE,MAAM,EAAE,CAAC;IACzB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,SAAS,EAAE,OAAO,CAAC;CACpB;AA6HD,wBAAsB,YAAY,CAAC,OAAO,EAAE,mBAAmB,EAAE,OAAO,GAAE,mBAAwB,GAAG,OAAO,CAAC,IAAI,CAAC,CAMjH;AAED,wBAAsB,YAAY,CAAC,OAAO,GAAE,mBAAwB,GAAG,OAAO,CAAC,mBAAmB,EAAE,CAAC,CA8CpG;AAED,wBAAsB,aAAa,CAAC,OAAO,GAAE,mBAAwB,GAAG,OAAO,CAAC,mBAAmB,EAAE,CAAC,CAcrG;AAgGD,wBAAsB,aAAa,CAAC,OAAO,GAAE,mBAAwB,GAAG,OAAO,CAAC,mBAAmB,CAAC,CAenG;AAED,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,UAAU,CA0DvD;AAyBD,wBAAgB,iBAAiB,CAAC,SAAS,SAAkB,EAAE,SAAS,SAAkB,GAAG,OAAO,CAMnG;AAED,wBAAsB,IAAI,CAAC,IAAI,WAAwB,GAAG,OAAO,CAAC,IAAI,CAAC,CAStE"}

package/dist/scripts/resolve-paths.js

@@ -0,0 +1,347 @@
+import { cp, glob, mkdir, rm, stat } from 'node:fs/promises';
+import { realpathSync, watch } from 'node:fs';
+import { basename, dirname, isAbsolute, relative, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { replaceTscAliasPaths } from 'tsc-alias';
+import { loadConfig, prepareConfig } from 'tsc-alias/dist/helpers/config.js';
+import { Output, TrieNode } from 'tsc-alias/dist/utils/index.js';
+const DEFAULT_INPUTS = ['tsconfig.json'];
+const GLOB_EXCLUDES = ['**/node_modules/**', '**/.git/**', '**/.svelte-kit/**', '**/dist/**'];
+const LABEL = '[resolve-paths]';
+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 logInfo(message) {
+    console.log(`${LABEL} ${message}`);
+}
+function logError(message) {
+    console.error(`${LABEL} ${message}`);
+}
+async function pathExists(targetPath) {
+    try {
+        await stat(targetPath);
+        return true;
+    }
+    catch (error) {
+        if (error.code === 'ENOENT') {
+            return false;
+        }
+        throw error;
+    }
+}
+async function resolveDirectInput(input, cwd) {
+    const absoluteInputPath = isAbsolute(input) ? input : resolve(cwd, input);
+    if (!(await pathExists(absoluteInputPath))) {
+        return [];
+    }
+    const inputStats = await stat(absoluteInputPath);
+    if (inputStats.isDirectory()) {
+        const nestedTsconfigPath = resolve(absoluteInputPath, 'tsconfig.json');
+        return (await pathExists(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 createSilentOutput() {
+    return new Output(false, false);
+}
+async function createFilteredAliasTrie(project, excludedAliases) {
+    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: project.distDir,
+        output
+    });
+    return TrieNode.buildAliasTrie(preparedConfig, filteredPaths);
+}
+async function resolveAliases(project, options = {}) {
+    await replaceTscAliasPaths({
+        aliasTrie: await createFilteredAliasTrie(project, options.excludeAliases ?? []),
+        configFile: project.tsconfigPath,
+        outDir: project.distDir,
+        fileExtensions: {
+            inputGlob: REPLACEABLE_FILE_EXTENSIONS.inputGlob,
+            outputCheck: [...REPLACEABLE_FILE_EXTENSIONS.outputCheck]
+        }
+    });
+}
+async function copyProjectSource(project) {
+    await rm(project.distDir, {
+        force: true,
+        recursive: true
+    });
+    await mkdir(project.rootDir, { recursive: true });
+    await cp(project.srcDir, project.distDir, {
+        force: true,
+        recursive: true
+    });
+}
+export async function buildProject(project, options = {}) {
+    await copyProjectSource(project);
+    await resolveAliases(project, {
+        ...options,
+        excludeAliases: [...new Set((options.excludeAliases ?? []).map(normalizeAliasPrefix).filter(Boolean))]
+    });
+}
+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 pathExists(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 timer;
+    const run = async () => {
+        if (closed) {
+            return;
+        }
+        if (activeBuild) {
+            return;
+        }
+        const reason = pendingReason ?? 'change';
+        pendingReason = undefined;
+        activeBuild = (async () => {
+            logInfo(`rebuilding ${formatPath(project.tsconfigPath, cwd)} after ${reason}`);
+            await buildProject(project, options);
+            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) {
+            if (closed) {
+                return;
+            }
+            pendingReason = reason;
+            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) => {
+        const suffix = fileName ? ` (${fileName.toString()})` : '';
+        runner.schedule(`src change${suffix}`);
+    });
+    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.unit.test.d.ts

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

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

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

package/dist/scripts/resolve-paths.unit.test.js

@@ -0,0 +1,167 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { mkdir, mkdtemp, readFile, rm, symlink, unlink, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { pathToFileURL } from 'node:url';
+import { buildProjects, isDirectExecution, watchProjects } from './resolve-paths.js';
+const tempDirectories = [];
+async function createTempDirectory(prefix) {
+    const directory = await mkdtemp(join(tmpdir(), prefix));
+    tempDirectories.push(directory);
+    return directory;
+}
+async function writeJson(filePath, value) {
+    await writeFile(filePath, JSON.stringify(value, null, 2));
+}
+async function createProject(root) {
+    await mkdir(join(root, 'src', 'lib'), { recursive: true });
+    await mkdir(join(root, 'src', 'components'), { recursive: true });
+    await writeJson(join(root, 'tsconfig.json'), {
+        compilerOptions: {
+            baseUrl: '.',
+            paths: {
+                '$components/*': ['src/components/*'],
+                '$lib/*': ['src/lib/*']
+            }
+        }
+    });
+    await writeFile(join(root, 'src', 'index.ts'), [
+        "import { answer } from '../utils';",
+        "import Button from '../components/Button.svelte';",
+        '',
+        'export { answer, Button };',
+        ''
+    ].join('\n'));
+    await writeFile(join(root, 'src', 'lib', 'utils.ts'), 'export const answer = 42;\n');
+    await writeFile(join(root, 'src', 'components', 'Button.svelte'), '<button>Click</button>\n');
+    await writeFile(join(root, 'src', 'styles.css'), '.root { color: red; }\n');
+}
+async function createProjectWithExternalAlias(root) {
+    const sharedRoot = join(root, '..', 'shared');
+    await mkdir(join(root, 'src', 'lib'), { recursive: true });
+    await mkdir(sharedRoot, { recursive: true });
+    await writeJson(join(root, 'tsconfig.json'), {
+        compilerOptions: {
+            baseUrl: '.',
+            paths: {
+                '$lib/*': ['src/lib/*'],
+                '$shared/*': ['../shared/*']
+            }
+        },
+        include: ['src/**/*.ts']
+    });
+    await writeFile(join(root, 'src', 'index.ts'), [
+        "import { answer } from '../utils';",
+        "import { sharedAnswer } from '$shared/utils';",
+        '',
+        'export { answer, sharedAnswer };',
+        ''
+    ].join('\n'));
+    await writeFile(join(root, 'src', 'lib', 'utils.ts'), 'export const answer = 42;\n');
+    await writeFile(join(sharedRoot, 'utils.ts'), 'export const sharedAnswer = 7;\n');
+}
+async function waitFor(assertion, timeoutMs = 5000) {
+    const deadline = Date.now() + timeoutMs;
+    let lastError;
+    while (Date.now() < deadline) {
+        try {
+            await assertion();
+            return;
+        }
+        catch (error) {
+            lastError = error;
+            await new Promise((resolve) => setTimeout(resolve, 50));
+        }
+    }
+    throw lastError;
+}
+describe('resolve-paths', () => {
+    beforeEach(() => {
+        vi.restoreAllMocks();
+        vi.spyOn(console, 'log').mockImplementation(() => { });
+        vi.spyOn(console, 'error').mockImplementation(() => { });
+    });
+    afterEach(async () => {
+        vi.restoreAllMocks();
+        await Promise.all(tempDirectories.splice(0).map((directory) => rm(directory, {
+            force: true,
+            recursive: true
+        })));
+    });
+    it('copies a project src tree into dist and resolves tsconfig path aliases', async () => {
+        const root = await createTempDirectory('resolve-paths-project-');
+        await createProject(root);
+        const projects = await buildProjects({
+            inputs: [join(root, 'tsconfig.json')]
+        });
+        expect(projects).toHaveLength(1);
+        await expect(readFile(join(root, 'dist', 'lib', 'utils.ts'), 'utf8')).resolves.toBe('export const answer = 42;\n');
+        await expect(readFile(join(root, 'dist', 'styles.css'), 'utf8')).resolves.toBe('.root { color: red; }\n');
+        const indexSource = await readFile(join(root, 'dist', 'index.ts'), 'utf8');
+        expect(indexSource).toContain("from './lib/utils'");
+        expect(indexSource).toContain("from './components/Button.svelte'");
+        expect(indexSource).not.toContain('$lib/utils');
+        expect(indexSource).not.toContain('$components/Button.svelte');
+    });
+    it('supports globbed tsconfig inputs across multiple projects', async () => {
+        const workspaceRoot = await createTempDirectory('resolve-paths-workspace-');
+        const packageARoot = join(workspaceRoot, 'packages', 'a');
+        const packageBRoot = join(workspaceRoot, 'packages', 'b');
+        await createProject(packageARoot);
+        await createProject(packageBRoot);
+        const projects = await buildProjects({
+            cwd: workspaceRoot,
+            inputs: ['packages/*/tsconfig.json']
+        });
+        expect(projects).toHaveLength(2);
+        const packageAIndex = await readFile(join(packageARoot, 'dist', 'index.ts'), 'utf8');
+        const packageBIndex = await readFile(join(packageBRoot, 'dist', 'index.ts'), 'utf8');
+        expect(packageAIndex).toContain("from './lib/utils'");
+        expect(packageBIndex).toContain("from './components/Button.svelte'");
+    });
+    it('does not resolve explicitly excluded aliases', async () => {
+        const root = await createTempDirectory('resolve-paths-excluded-alias-');
+        await createProjectWithExternalAlias(root);
+        await buildProjects({
+            excludeAliases: ['$shared'],
+            inputs: [join(root, 'tsconfig.json')]
+        });
+        const indexSource = await readFile(join(root, 'dist', 'index.ts'), 'utf8');
+        expect(indexSource).toContain("from './lib/utils'");
+        expect(indexSource).toContain("from '$shared/utils'");
+        expect(indexSource).not.toContain('../shared/utils');
+    });
+    it('rebuilds dist in watch mode when src files change or are removed', async () => {
+        const root = await createTempDirectory('resolve-paths-watch-');
+        await createProject(root);
+        const watcher = await watchProjects({
+            inputs: [join(root, 'tsconfig.json')]
+        });
+        try {
+            await writeFile(join(root, 'src', 'index.ts'), ["import { answer } from '../utils';", '', 'export const doubled = answer * 2;', ''].join('\n'));
+            await unlink(join(root, 'src', 'styles.css'));
+            await waitFor(async () => {
+                const indexSource = await readFile(join(root, 'dist', 'index.ts'), 'utf8');
+                expect(indexSource).toContain("from './lib/utils'");
+                expect(indexSource).toContain('export const doubled = answer * 2;');
+                expect(indexSource).not.toContain('$lib/utils');
+            });
+            await waitFor(async () => {
+                await expect(readFile(join(root, 'dist', 'styles.css'), 'utf8')).rejects.toMatchObject({
+                    code: 'ENOENT'
+                });
+            });
+        }
+        finally {
+            watcher.close();
+        }
+    });
+    it('treats symlinked entry paths as direct execution of the same module', async () => {
+        const root = await createTempDirectory('resolve-paths-symlink-');
+        const actualFilePath = join(root, 'actual.js');
+        const symlinkPath = join(root, 'linked.js');
+        await writeFile(actualFilePath, 'export {};\n');
+        await symlink(actualFilePath, symlinkPath);
+        expect(isDirectExecution(symlinkPath, pathToFileURL(actualFilePath).href)).toBe(true);
+    });
+});

package/dist/vite/vite-plugin-component-source-collector.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"vite-plugin-component-source-collector.d.ts","sourceRoot":"","sources":["../../src/lib/vite/vite-plugin-component-source-collector.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAkB,MAAM,MAAM,CAAC;AAMnD,UAAU,OAAO;IACf;;;;OAIG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB;;OAEG;IACH,OAAO,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;IAC5B;;OAEG;IACH,YAAY,EAAE,MAAM,EAAE,CAAC;CACxB;AA2CD,wBAA8B,wBAAwB,CAAC,IAAI,GAAE,OAA8B,GAAG,OAAO,CAAC,MAAM,CAAC,CAuN5G"}
+{"version":3,"file":"vite-plugin-component-source-collector.d.ts","sourceRoot":"","sources":["../../src/lib/vite/vite-plugin-component-source-collector.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAkB,MAAM,MAAM,CAAC;AAMnD,UAAU,OAAO;IACf;;;;OAIG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB;;OAEG;IACH,OAAO,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;IAC5B;;OAEG;IACH,YAAY,EAAE,MAAM,EAAE,CAAC;CACxB;AA4CD,wBAA8B,wBAAwB,CAAC,IAAI,GAAE,OAA8B,GAAG,OAAO,CAAC,MAAM,CAAC,CA2M5G"}

package/dist/vite/vite-plugin-component-source-collector.js

@@ -93,7 +93,6 @@ export default async function componentSourceCollector(opts = { safePackages: []
         const relativeFilePath = toPosixPath(relative(dirname(outputFilePath), normalizedFilePath));
         if (normalizedFilePath === outputFilePath || relativeFilePath === outFileName)
             return;
-        // Dont add itself
         componentFiles.add(ensureDotRelative(relativeFilePath));
     }
     function scheduleInitialWrite() {
@@ -101,14 +100,14 @@ export default async function componentSourceCollector(opts = { safePackages: []
             clearTimeout(initialTransformTimer);
         initialTransformTimer = setTimeout(() => {
             if (!initialTransformDone) {
-                writeOutFile();
+                void writeOutFile();
                 initialTransformDone = true;
             }
         }, 1000);
     }
     const writeOutFile = async () => {
         const lines = Array.from(componentFiles)
-            .map((d) => `@source '${d}';`)
+            .map((filePath) => `@source '${filePath}';`)
             .sort();
         if (outputFilePath) {
             const didWrite = await writeIfDifferent(outputFilePath, lines.join('\n'));
@@ -116,13 +115,9 @@ export default async function componentSourceCollector(opts = { safePackages: []
                 console.log('tailwind-sources:wrote', lines.length);
         }
     };
-    // ---- plugin ---- //
     return {
         name: 'vite-plugin-component-source-collector',
-        enforce: 'pre', // i want to see comments
-        /**
-         * Setup. Add exisitng files to internal state if dev
-         */
+        enforce: 'pre',
         async configResolved(resolved) {
             config = resolved;
             outputFilePath = resolve(config.root, outFileName);
@@ -132,8 +127,7 @@ export default async function componentSourceCollector(opts = { safePackages: []
                     nodeModulesPath = join(current, 'node_modules');
                     break;
                 }
-                else
-                    current = dirname(current);
+                current = dirname(current);
             }
             console.log('tailwind-sources:configResolved: Command is', config.command);
             await touch(outputFilePath);
@@ -176,9 +170,8 @@ export default async function componentSourceCollector(opts = { safePackages: []
                 'bun.lockb',
                 'bun.lock',
                 'npm-shrinkwrap.json',
-                // pnpm install-state changes:
                 'node_modules/.modules.yaml'
-            ].map((p) => join(config.root, p));
+            ].map((path) => join(config.root, path));
             server.watcher.add(lockFiles);
             const onChange = async (file) => {
                 if (!lockFiles.includes(file))
@@ -198,7 +191,6 @@ export default async function componentSourceCollector(opts = { safePackages: []
             if (id.includes('css') && code.includes('@import')) {
                 const matches = code.matchAll(importRegex);
                 for (const match of matches) {
-                    // console.log('MATching', match);
                     try {
                         const resolved = await this.resolve(match[1], id);
                         if (resolved) {
@@ -206,11 +198,10 @@ export default async function componentSourceCollector(opts = { safePackages: []
                         }
                     }
                     catch {
-                        // Cant resolve: dont add
+                        // Ignore unresolved CSS imports while building the Tailwind source list.
                     }
                 }
             }
-            // Adds all other files with the classRegex
             if (shouldAdd(code, id)) {
                 await addPath(id);
             }
@@ -218,7 +209,7 @@ export default async function componentSourceCollector(opts = { safePackages: []
                 scheduleInitialWrite();
             }
         },
-        async handleHotUpdate(_ctx) {
+        async handleHotUpdate() {
             await writeOutFile();
         },
         async buildEnd() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "svelte-ag",
-  "version": "1.0.67",
+  "version": "1.0.68",
   "description": "Useful svelte components",
   "bugs": "https://github.com/ageorgeh/svelte-ag/issues",
   "repository": {
@@ -25,6 +25,9 @@
       "default": "./dist/*"
     }
   },
+  "bin": {
+    "resolve-paths": "dist/scripts/resolve-paths.js"
+  },
   "files": [
     "./src/lib",
     "./dist"
@@ -60,6 +63,7 @@
     "tailwind-merge": "^3.5.0",
     "tailwind-variants": "^3.2.2",
     "ts-ag": "^1.1.14",
+    "tsc-alias": "^1.8.16",
     "valibot": "^1.3.1"
   },
   "devDependencies": {