@svelte-lean/vite 0.1.0

package/dist/plugin.js

@@ -0,0 +1,214 @@
+import { isAbsolute, resolve } from 'node:path';
+import { BUILTIN_BEHAVIORS, modulesFor, resolveBehavior } from './behaviors.js';
+import { createIdFilter, normalizePath, parseId, relativeToRoot } from './filter.js';
+import { createManifest, writeManifest } from './manifest.js';
+import { formatDynamicWarning, formatReport, formatUnknownWarning, formatUnterminatedWarning } from './report.js';
+import { scan } from './scanner.js';
+export const SCAN_PLUGIN_NAME = 'svelte-lean:scan';
+export const INJECT_PLUGIN_NAME = 'svelte-lean:inject';
+export const DEFAULT_MANIFEST_PATH = 'node_modules/.svelte-lean/manifest.json';
+function toArray(value, fallback) {
+    if (value === undefined)
+        return fallback;
+    return Array.isArray(value) ? value : [value];
+}
+export function resolveOptions(options = {}) {
+    const behaviors = options.behaviors ?? {};
+    for (const [name, value] of Object.entries(behaviors)) {
+        if (value !== false && (typeof value !== 'string' || value.length === 0)) {
+            throw new Error(`svelteLean(): behaviors.${name} must be a module specifier string or false.`);
+        }
+    }
+    const ssr = options.ssr ?? 'skip';
+    if (ssr !== 'skip' && ssr !== 'inject') {
+        throw new Error(`svelteLean(): ssr must be 'skip' or 'inject', got ${JSON.stringify(ssr)}.`);
+    }
+    const manifest = options.manifest ?? true;
+    return {
+        include: toArray(options.include, ['**/*.svelte']),
+        exclude: toArray(options.exclude, ['**/node_modules/**']),
+        package: options.package ?? '@svelte-lean/primitives',
+        behaviors,
+        manifest: manifest === true ? DEFAULT_MANIFEST_PATH : manifest === false ? false : manifest,
+        report: options.report ?? false,
+        warnDynamic: options.warnDynamic ?? true,
+        ssr
+    };
+}
+/**
+ * Appends one side-effect import per registration module. Imports are hoisted by the module
+ * system, so evaluation order is identical to a prepended import, while appending keeps every
+ * existing line and column in place: `map: null` is then the correct source-map answer ("the
+ * transform did not move code"), and the compiler's map for the module stays valid.
+ */
+export function appendImports(code, modules) {
+    if (modules.length === 0)
+        return code;
+    const statements = modules.map((module) => `import '${escapeSpecifier(module)}';`);
+    const separator = code.length === 0 || code.endsWith('\n') ? '' : '\n';
+    return code + separator + statements.join('\n') + '\n';
+}
+function escapeSpecifier(specifier) {
+    // JSON escaping covers backslashes, control characters and double quotes; single quotes are
+    // the only remaining character that would end the literal.
+    return JSON.stringify(specifier).slice(1, -1).replace(/'/g, "\\'");
+}
+/**
+ * Packages kept out of the dev server's dependency pre-bundling. The registration imports are
+ * added by the inject transform, after Vite's dependency scan has read the raw source, so a
+ * pre-bundled package would be discovered on the first page that uses a behavior, re-optimized,
+ * and the page fully reloaded. Excluded, the packages are served as the plain ES modules they are
+ * (no CommonJS, no dependencies outside the scope), core stays a single instance, and HMR of the
+ * registration modules behaves as it does for linked workspace packages. A package the user lists
+ * in `optimizeDeps.include` is left to the user.
+ */
+export function optimizeDepsExclude(options, userConfig = {}) {
+    const include = userConfig.optimizeDeps?.include ?? [];
+    const listed = (name) => include.some((entry) => entry === name || entry.startsWith(name + '/'));
+    return [...new Set([options.package, '@svelte-lean/core'])].filter((name) => !listed(name));
+}
+/**
+ * Creates the two plugins. `svelte-lean:scan` (`enforce: 'pre'`) reads Svelte source before the
+ * compiler and records which behaviors each file uses; `svelte-lean:inject` (`enforce: 'post'`)
+ * adds the registration imports to the compiled module. They share state through this closure.
+ */
+export function svelteLean(userOptions = {}) {
+    const options = resolveOptions(userOptions);
+    const state = {
+        root: normalizePath(process.cwd()),
+        isBuild: false,
+        config: null,
+        filter: () => false,
+        usage: new Map(),
+        dynamic: new Map(),
+        warnedDynamic: new Set(),
+        warnedUnknown: new Set(),
+        warnedUnterminated: new Set()
+    };
+    const reset = () => {
+        state.usage.clear();
+        state.dynamic.clear();
+        state.warnedDynamic.clear();
+        state.warnedUnknown.clear();
+        state.warnedUnterminated.clear();
+    };
+    const configResolved = (config) => {
+        state.config = config;
+        state.root = normalizePath(config.root);
+        state.isBuild = config.command === 'build';
+        state.filter = createIdFilter({
+            root: state.root,
+            include: options.include,
+            exclude: options.exclude
+        });
+    };
+    const manifestPath = () => options.manifest === false
+        ? null
+        : isAbsolute(options.manifest)
+            ? options.manifest
+            : resolve(state.root, options.manifest);
+    const display = (file) => relativeToRoot(state.root, file) ?? file;
+    const scanPlugin = {
+        name: SCAN_PLUGIN_NAME,
+        enforce: 'pre',
+        config(userConfig) {
+            return { optimizeDeps: { exclude: optimizeDepsExclude(options, userConfig) } };
+        },
+        configResolved,
+        buildStart() {
+            reset();
+        },
+        watchChange(id, change) {
+            const { file } = parseId(id);
+            if (change?.event === 'delete') {
+                state.usage.delete(file);
+                state.dynamic.delete(file);
+            }
+            state.warnedDynamic.delete(file);
+            state.warnedUnterminated.delete(file);
+        },
+        transform(code, id) {
+            if (!state.filter(id))
+                return null;
+            const { file } = parseId(id);
+            if (!code.includes('data-slean')) {
+                state.usage.delete(file);
+                state.dynamic.delete(file);
+                return null;
+            }
+            const result = scan(code, file);
+            if (result.behaviors.size)
+                state.usage.set(file, result.behaviors);
+            else
+                state.usage.delete(file);
+            if (result.dynamic.length)
+                state.dynamic.set(file, result.dynamic);
+            else
+                state.dynamic.delete(file);
+            for (const name of result.behaviors) {
+                if (state.warnedUnknown.has(name))
+                    continue;
+                if (resolveBehavior(name, options).kind !== 'unknown')
+                    continue;
+                state.warnedUnknown.add(name);
+                const known = [...Object.keys(BUILTIN_BEHAVIORS), ...Object.keys(options.behaviors)];
+                this.warn(formatUnknownWarning(name, display(file), [...new Set(known)].sort()));
+            }
+            if (result.unterminated && !state.warnedUnterminated.has(file)) {
+                state.warnedUnterminated.add(file);
+                this.warn(formatUnterminatedWarning(display(file), result.unterminated), {
+                    line: result.unterminated.line,
+                    column: result.unterminated.column - 1
+                });
+            }
+            if (options.warnDynamic && result.dynamic.length && !state.warnedDynamic.has(file)) {
+                state.warnedDynamic.add(file);
+                const first = result.dynamic[0];
+                // Rollup and Vite expect a 0-based column here; the scanner reports 1-based columns.
+                this.warn(formatDynamicWarning(display(file), result.dynamic), {
+                    line: first.line,
+                    column: first.column - 1
+                });
+            }
+            return null;
+        }
+    };
+    const injectPlugin = {
+        name: INJECT_PLUGIN_NAME,
+        enforce: 'post',
+        configResolved,
+        transform(code, id, transformOptions) {
+            if (!state.filter(id))
+                return null;
+            // Vite 6+ passes `ssr` for compatibility; the environment consumer is the primary signal.
+            const ssr = transformOptions?.ssr ?? this.environment?.config?.consumer === 'server';
+            if (ssr && options.ssr === 'skip')
+                return null;
+            const names = state.usage.get(parseId(id).file);
+            if (!names || names.size === 0)
+                return null;
+            const modules = modulesFor(names, options);
+            if (modules.length === 0)
+                return null;
+            return { code: appendImports(code, modules), map: null };
+        },
+        async buildEnd(error) {
+            if (error || !state.isBuild)
+                return;
+            const path = manifestPath();
+            if (path === null)
+                return;
+            await writeManifest(path, createManifest({ ...state, options }));
+        },
+        closeBundle() {
+            if (!options.report || !state.isBuild || !state.config)
+                return;
+            if (state.config.build.ssr)
+                return;
+            const path = manifestPath();
+            const manifest = createManifest({ ...state, options });
+            state.config.logger.info('\n' + formatReport(manifest, path && display(normalizePath(path))));
+        }
+    };
+    return [scanPlugin, injectPlugin];
+}

package/dist/report.d.ts

@@ -0,0 +1,13 @@
+import type { BehaviorManifest, DynamicMarker } from './types.js';
+/**
+ * Human-readable build report. It only states what the scan observed: native-only names, the
+ * registration modules that were injected and the files that caused each of them, unknown names
+ * and dynamic markers. It makes no size or timing claims.
+ */
+export declare function formatReport(manifest: BehaviorManifest, manifestPath: string | null): string;
+export declare function formatDynamicWarning(file: string, markers: readonly DynamicMarker[]): string;
+export declare function formatUnterminatedWarning(file: string, position: {
+    line: number;
+    column: number;
+}): string;
+export declare function formatUnknownWarning(name: string, file: string, known: string[]): string;

package/dist/report.js

@@ -0,0 +1,70 @@
+const LABEL_WIDTH = 13;
+function row(label, first, rest = []) {
+    const pad = ' '.repeat(LABEL_WIDTH);
+    return [
+        '  ' + label.padEnd(LABEL_WIDTH) + first,
+        ...rest.map((line) => '  ' + pad + '  ' + line)
+    ];
+}
+/**
+ * Human-readable build report. It only states what the scan observed: native-only names, the
+ * registration modules that were injected and the files that caused each of them, unknown names
+ * and dynamic markers. It makes no size or timing claims.
+ */
+export function formatReport(manifest, manifestPath) {
+    const native = [];
+    const runtime = [];
+    const unknown = new Set(manifest.unknown);
+    for (const [name, entry] of Object.entries(manifest.behaviors)) {
+        if (entry.module !== null)
+            runtime.push([name, { files: entry.files, module: entry.module }]);
+        else if (!unknown.has(name))
+            native.push(name);
+    }
+    const lines = ['svelte-lean build report'];
+    lines.push(...row('native-only', native.length ? native.join(', ') : 'none'));
+    if (runtime.length === 0) {
+        lines.push(...row('runtime', 'none'));
+    }
+    else {
+        runtime.forEach(([name, entry], index) => {
+            const head = `${name} -> ${entry.module}`;
+            lines.push(...(index === 0 ? row('runtime', head, entry.files) : row('', head, entry.files)));
+        });
+    }
+    lines.push(...row('unknown', manifest.unknown.length
+        ? manifest.unknown
+            .map((name) => `${name} (${manifest.behaviors[name]?.files.join(', ') ?? ''})`)
+            .join(', ')
+        : 'none'));
+    const dynamicLines = Object.entries(manifest.dynamic).flatMap(([file, markers]) => markers.map((marker) => `${file}:${marker.line} data-slean=${marker.expression}`));
+    lines.push(...(dynamicLines.length
+        ? row('dynamic', dynamicLines[0], dynamicLines.slice(1))
+        : row('dynamic', 'none')));
+    lines.push(...row('manifest', manifestPath ?? 'not written'));
+    return lines.join('\n');
+}
+export function formatDynamicWarning(file, markers) {
+    const found = markers.map((marker) => `  ${file}:${marker.line}:${marker.column}  data-slean=${marker.expression}`);
+    return [
+        'Dynamic behavior identifiers cannot be auto-discovered.',
+        'Found:',
+        ...found,
+        'Use a static identifier such as data-slean="tabs", or import the registration module',
+        "manually (for example import '@svelte-lean/primitives/tabs/register')."
+    ].join('\n');
+}
+export function formatUnterminatedWarning(file, position) {
+    return [
+        `Svelte Lean scanner stopped at ${file}:${position.line}:${position.column}: the { expression starting there never closes.`,
+        'Markers after that point are not discovered. Check the expression, or import the registration',
+        "module manually (for example import '@svelte-lean/primitives/tabs/register')."
+    ].join('\n');
+}
+export function formatUnknownWarning(name, file, known) {
+    return [
+        `Unknown Svelte Lean behavior "${name}" in ${file}.`,
+        `Known behaviors: ${known.join(', ')}.`,
+        `Map it with svelteLean({ behaviors: { ${JSON.stringify(name)}: '<module specifier>' } }), or to false if it needs no runtime.`
+    ].join('\n');
+}

package/dist/scanner.d.ts

@@ -0,0 +1,19 @@
+import type { ScanResult } from './types.js';
+/** 1-based line and column of `index` in `source`. */
+export declare function locate(source: string, index: number): {
+    line: number;
+    column: number;
+};
+/**
+ * Skips a balanced `{ … }` Svelte expression starting at `start` (which must be `{`) and
+ * returns the index after the closing brace. String, template and regular-expression literals
+ * and comments inside the expression are skipped so braces and quotes in them do not affect
+ * balancing. When the expression never closes, the end of the source is returned and, given a
+ * `result`, the position of the outermost unterminated expression is recorded once.
+ */
+export declare function skipExpression(source: string, start: number, result?: ScanResult): number;
+/**
+ * Finds static `data-slean="name"` markers and dynamic `data-slean={…}` markers in Svelte source.
+ * Pure: no I/O, no plugin context. `id` is only carried into the result for diagnostics.
+ */
+export declare function scan(source: string, id?: string): ScanResult;