@svelte-lean/vite 0.1.0

package/dist/scanner.js

@@ -0,0 +1,394 @@
+/**
+ * Lexical scanner for Svelte Lean behavior markers.
+ *
+ * It understands exactly enough Svelte markup to avoid false positives:
+ * `<script>` / `<style>` raw text, HTML comments, quoted attribute values (including the
+ * `{expression}` parts Svelte allows inside them) and `{expression}` tags in text. It does not
+ * build an AST and does not depend on the Svelte compiler; block tags such as `{#if}` are skipped
+ * like any other expression because discovery is about markup only. Inside an expression,
+ * string, template and regular-expression literals and comments are skipped so their quotes and
+ * braces cannot unbalance it; an expression that never closes is recorded in
+ * `ScanResult.unterminated` so a miss is never silent.
+ */
+const ATTRIBUTE = 'data-slean';
+const RAW_TEXT_ELEMENTS = new Set(['script', 'style']);
+const TAB = 9;
+const NL = 10;
+const FF = 12;
+const CR = 13;
+const SPACE = 32;
+const BANG = 33;
+const DQUOTE = 34;
+const DOLLAR = 36;
+const SQUOTE = 39;
+const STAR = 42;
+const SLASH = 47;
+const LT = 60;
+const EQ = 61;
+const GT = 62;
+const QUESTION = 63;
+const BACKSLASH = 92;
+const BACKTICK = 96;
+const LBRACE = 123;
+const RBRACE = 125;
+const LBRACKET = 91;
+const RBRACKET = 93;
+const RPAREN = 41;
+const UNDERSCORE = 95;
+/** Identifiers after which a `/` starts a regular expression rather than a division. */
+const REGEX_AFTER_KEYWORD = new Set([
+    'return',
+    'typeof',
+    'instanceof',
+    'in',
+    'of',
+    'new',
+    'delete',
+    'void',
+    'throw',
+    'case',
+    'do',
+    'else',
+    'yield',
+    'await',
+    'if',
+    'while',
+    'each'
+]);
+function isWhitespace(c) {
+    return c === SPACE || c === NL || c === TAB || c === CR || c === FF;
+}
+function isAsciiLetter(c) {
+    return (c >= 65 && c <= 90) || (c >= 97 && c <= 122);
+}
+function isIdentifierChar(c) {
+    return isAsciiLetter(c) || (c >= 48 && c <= 57) || c === UNDERSCORE || c === DOLLAR || c > 127;
+}
+/** 1-based line and column of `index` in `source`. */
+export function locate(source, index) {
+    let line = 1;
+    let lineStart = 0;
+    for (let i = 0; i < index; i++) {
+        if (source.charCodeAt(i) === NL) {
+            line++;
+            lineStart = i + 1;
+        }
+    }
+    return { line, column: index - lineStart + 1 };
+}
+/** ASCII case-insensitive `indexOf`; never lowercases the source (that can change its length). */
+function indexOfIgnoreCase(source, needle, from) {
+    const n = source.length - needle.length;
+    outer: for (let i = from; i <= n; i++) {
+        for (let j = 0; j < needle.length; j++) {
+            let c = source.charCodeAt(i + j);
+            if (c >= 65 && c <= 90)
+                c += 32;
+            if (c !== needle.charCodeAt(j))
+                continue outer;
+        }
+        return i;
+    }
+    return -1;
+}
+function skipUntilChar(source, from, char) {
+    for (let i = from; i < source.length; i++) {
+        if (source.charCodeAt(i) === char)
+            return i + 1;
+    }
+    return source.length;
+}
+function skipStringLiteral(source, start, quote) {
+    for (let i = start + 1; i < source.length; i++) {
+        const c = source.charCodeAt(i);
+        if (c === BACKSLASH) {
+            i++;
+        }
+        else if (c === quote) {
+            return i + 1;
+        }
+        else if (c === NL) {
+            // Unterminated string: stop at the line end instead of swallowing the rest of the file.
+            return i;
+        }
+    }
+    return source.length;
+}
+function skipTemplateLiteral(source, start, result) {
+    for (let i = start + 1; i < source.length; i++) {
+        const c = source.charCodeAt(i);
+        if (c === BACKSLASH) {
+            i++;
+        }
+        else if (c === BACKTICK) {
+            return i + 1;
+        }
+        else if (c === DOLLAR && source.charCodeAt(i + 1) === LBRACE) {
+            i = skipExpression(source, i + 1, result) - 1;
+        }
+    }
+    return source.length;
+}
+/**
+ * Whether a `/` at `index` starts a regular expression literal. Decided from the previous
+ * significant character, as JavaScript tokenizers do: after an operand (identifier, number,
+ * `)` or `]`) it is a division; after an operator, an opening bracket or a keyword such as
+ * `return` it is a regular expression. A slash directly after the expression's `{` is a Svelte
+ * block close (`{/if}`, `{/each}`), so it is never treated as a literal.
+ */
+function isRegexStart(source, index, start) {
+    let i = index - 1;
+    while (i > start && isWhitespace(source.charCodeAt(i)))
+        i--;
+    // Directly after the opening brace it is a Svelte block close (`{/if}`), not a literal.
+    if (i <= start)
+        return false;
+    const c = source.charCodeAt(i);
+    if (c === RPAREN || c === RBRACKET)
+        return false;
+    if (!isIdentifierChar(c))
+        return true;
+    let wordStart = i;
+    while (wordStart > start && isIdentifierChar(source.charCodeAt(wordStart - 1)))
+        wordStart--;
+    return REGEX_AFTER_KEYWORD.has(source.slice(wordStart, i + 1));
+}
+/** Skips a regular expression literal starting at `start` (`/`), including its flags. */
+function skipRegexLiteral(source, start) {
+    let inClass = false;
+    let i = start + 1;
+    for (; i < source.length; i++) {
+        const c = source.charCodeAt(i);
+        if (c === BACKSLASH) {
+            i++;
+        }
+        else if (c === NL) {
+            // Unterminated literal: stop at the line end instead of swallowing the rest of the file.
+            return i;
+        }
+        else if (inClass) {
+            if (c === RBRACKET)
+                inClass = false;
+        }
+        else if (c === LBRACKET) {
+            inClass = true;
+        }
+        else if (c === SLASH) {
+            i++;
+            break;
+        }
+    }
+    while (i < source.length && isAsciiLetter(source.charCodeAt(i)))
+        i++;
+    return i;
+}
+/**
+ * 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 function skipExpression(source, start, result) {
+    const n = source.length;
+    let depth = 0;
+    let i = start;
+    while (i < n) {
+        const c = source.charCodeAt(i);
+        if (c === LBRACE) {
+            depth++;
+            i++;
+        }
+        else if (c === RBRACE) {
+            depth--;
+            i++;
+            if (depth === 0)
+                return i;
+        }
+        else if (c === DQUOTE || c === SQUOTE) {
+            i = skipStringLiteral(source, i, c);
+        }
+        else if (c === BACKTICK) {
+            i = skipTemplateLiteral(source, i, result);
+        }
+        else if (c === SLASH && source.charCodeAt(i + 1) === SLASH) {
+            i = skipUntilChar(source, i, NL);
+        }
+        else if (c === SLASH && source.charCodeAt(i + 1) === STAR) {
+            const end = source.indexOf('*/', i + 2);
+            i = end === -1 ? n : end + 2;
+        }
+        else if (c === SLASH && isRegexStart(source, i, start)) {
+            i = skipRegexLiteral(source, i);
+        }
+        else {
+            i++;
+        }
+    }
+    if (result && !result.unterminated)
+        result.unterminated = locate(source, start);
+    return n;
+}
+function readAttributeValue(source, start, result) {
+    const n = source.length;
+    const first = source.charCodeAt(start);
+    if (first === DQUOTE || first === SQUOTE) {
+        let dynamic = false;
+        let i = start + 1;
+        while (i < n) {
+            const c = source.charCodeAt(i);
+            if (c === first)
+                break;
+            if (c === LBRACE) {
+                dynamic = true;
+                i = skipExpression(source, i, result);
+            }
+            else {
+                i++;
+            }
+        }
+        return { text: source.slice(start + 1, i), dynamic, end: Math.min(i + 1, n) };
+    }
+    if (first === LBRACE) {
+        const end = skipExpression(source, start, result);
+        return { text: source.slice(start, end), dynamic: true, end };
+    }
+    let dynamic = false;
+    let i = start;
+    while (i < n) {
+        const c = source.charCodeAt(i);
+        if (isWhitespace(c) || c === GT)
+            break;
+        if (c === SLASH && source.charCodeAt(i + 1) === GT)
+            break;
+        if (c === LBRACE) {
+            dynamic = true;
+            i = skipExpression(source, i, result);
+        }
+        else {
+            i++;
+        }
+    }
+    return { text: source.slice(start, i), dynamic, end: i };
+}
+function isAttributeNameEnd(source, i) {
+    const c = source.charCodeAt(i);
+    return (isWhitespace(c) ||
+        c === EQ ||
+        c === GT ||
+        c === LBRACE ||
+        c === DQUOTE ||
+        c === SQUOTE ||
+        (c === SLASH && source.charCodeAt(i + 1) === GT));
+}
+/** Scans one opening tag starting at `start` (`<`). Returns the index after the tag's content. */
+function scanTag(source, start, result) {
+    const n = source.length;
+    let i = start + 1;
+    const nameStart = i;
+    while (i < n && !isAttributeNameEnd(source, i))
+        i++;
+    const tagName = source.slice(nameStart, i).toLowerCase();
+    let selfClosing = false;
+    while (i < n) {
+        const c = source.charCodeAt(i);
+        if (isWhitespace(c)) {
+            i++;
+        }
+        else if (c === GT) {
+            i++;
+            break;
+        }
+        else if (c === SLASH) {
+            if (source.charCodeAt(i + 1) === GT) {
+                selfClosing = true;
+                i += 2;
+                break;
+            }
+            i++;
+        }
+        else if (c === LBRACE) {
+            // `{shorthand}` or `{...spread}` attribute.
+            i = skipExpression(source, i, result);
+        }
+        else if (c === DQUOTE || c === SQUOTE) {
+            // A stray quote is not valid Svelte; skip the quoted run so the tag still ends.
+            i = readAttributeValue(source, i, result).end;
+        }
+        else {
+            const attrStart = i;
+            while (i < n && !isAttributeNameEnd(source, i))
+                i++;
+            if (i === attrStart) {
+                i++;
+                continue;
+            }
+            const attrName = source.slice(attrStart, i);
+            let j = i;
+            while (j < n && isWhitespace(source.charCodeAt(j)))
+                j++;
+            if (source.charCodeAt(j) !== EQ)
+                continue;
+            j++;
+            while (j < n && isWhitespace(source.charCodeAt(j)))
+                j++;
+            const value = readAttributeValue(source, j, result);
+            i = value.end;
+            if (attrName.toLowerCase() !== ATTRIBUTE)
+                continue;
+            if (value.dynamic) {
+                const { line, column } = locate(source, attrStart);
+                const marker = { line, column, expression: source.slice(j, value.end) };
+                result.dynamic.push(marker);
+            }
+            else {
+                const name = value.text.trim();
+                // A bare `<select data-slean="select">` is the Tier 0 styled native select (ADR 0007):
+                // the owned select is a `<div data-slean="select">`, so only that marker needs the runtime.
+                if (name && !(tagName === 'select' && name === 'select'))
+                    result.behaviors.add(name);
+            }
+        }
+    }
+    if (!selfClosing && RAW_TEXT_ELEMENTS.has(tagName)) {
+        const close = indexOfIgnoreCase(source, '</' + tagName, i);
+        i = close === -1 ? n : skipUntilChar(source, close, GT);
+    }
+    return i;
+}
+/**
+ * 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 function scan(source, id) {
+    const result = { id, behaviors: new Set(), dynamic: [], unterminated: null };
+    const n = source.length;
+    let i = 0;
+    while (i < n) {
+        const c = source.charCodeAt(i);
+        if (c === LT) {
+            if (source.startsWith('<!--', i)) {
+                const end = source.indexOf('-->', i + 4);
+                i = end === -1 ? n : end + 3;
+                continue;
+            }
+            const next = source.charCodeAt(i + 1);
+            if (next === SLASH || next === BANG || next === QUESTION) {
+                i = skipUntilChar(source, i, GT);
+            }
+            else if (isAsciiLetter(next)) {
+                i = scanTag(source, i, result);
+            }
+            else {
+                i++;
+            }
+        }
+        else if (c === LBRACE) {
+            i = skipExpression(source, i, result);
+        }
+        else {
+            i++;
+        }
+    }
+    return result;
+}

package/dist/types.d.ts

@@ -0,0 +1,98 @@
+/**
+ * Options accepted by `svelteLean()`.
+ */
+export interface SvelteLeanOptions {
+    /**
+     * Files to scan. Globs are matched against the path relative to the Vite root and against
+     * the absolute path; `RegExp` values are tested against both as well.
+     * Default: `['**\/*.svelte']`.
+     */
+    include?: string | RegExp | Array<string | RegExp>;
+    /**
+     * Files never scanned or injected into. Default: `['**\/node_modules/**']`.
+     */
+    exclude?: string | RegExp | Array<string | RegExp>;
+    /**
+     * Package that provides the built-in registration modules. Built-in specifiers that start with
+     * `@svelte-lean/primitives/` are rewritten to start with this value instead.
+     * Default: `'@svelte-lean/primitives'`.
+     */
+    package?: string;
+    /**
+     * Behavior name → registration module specifier, or `false` for a behavior that needs no
+     * runtime. Entries override `BUILTIN_BEHAVIORS`.
+     */
+    behaviors?: Record<string, string | false>;
+    /**
+     * Write the behavior manifest at the end of a production build. `true` writes
+     * `node_modules/.svelte-lean/manifest.json` under the Vite root; a string is a path
+     * (resolved against the root). Default: `true`.
+     */
+    manifest?: boolean | string;
+    /**
+     * Print a build report after the client bundle is written. Default: `false`.
+     */
+    report?: boolean;
+    /**
+     * Warn (once per file and transform) about `data-slean={expression}` markers, which cannot be
+     * discovered statically. Default: `true`.
+     */
+    warnDynamic?: boolean;
+    /**
+     * `'skip'` (default) leaves server-side transforms untouched: the runtime is browser-only and
+     * registration modules are only needed in the client graph. `'inject'` also adds the imports
+     * to server modules; registration modules are SSR-safe, so this is only a bundle-size choice.
+     */
+    ssr?: 'skip' | 'inject';
+}
+export interface ResolvedOptions {
+    include: Array<string | RegExp>;
+    exclude: Array<string | RegExp>;
+    package: string;
+    behaviors: Record<string, string | false>;
+    /** `false`, or the manifest path relative to (or absolute from) the Vite root. */
+    manifest: string | false;
+    report: boolean;
+    warnDynamic: boolean;
+    ssr: 'skip' | 'inject';
+}
+/** A `data-slean` attribute whose value is not a static string. */
+export interface DynamicMarker {
+    /** 1-based line of the attribute in the Svelte source. */
+    line: number;
+    /** 1-based column of the attribute in the Svelte source. */
+    column: number;
+    /** The attribute value exactly as written, for example `{kind}` or `"tabs-{suffix}"`. */
+    expression: string;
+}
+export interface ScanResult {
+    /** The module id passed to `scan()`, if any. */
+    id: string | undefined;
+    /** Static behavior names found in markup, in first-seen order. */
+    behaviors: Set<string>;
+    /** Dynamic markers, in source order. */
+    dynamic: DynamicMarker[];
+    /**
+     * 1-based position of the first `{` expression that never closed, or `null`. Markup after
+     * that point was not scanned, so any marker in it is not discovered.
+     */
+    unterminated: {
+        line: number;
+        column: number;
+    } | null;
+}
+export interface ManifestBehavior {
+    /** Files that use the behavior, relative to the Vite root, sorted. */
+    files: string[];
+    /** Injected registration module, or `null` for native and unknown behaviors. */
+    module: string | null;
+}
+export interface BehaviorManifest {
+    version: 1;
+    behaviors: Record<string, ManifestBehavior>;
+    dynamic: Record<string, Array<{
+        line: number;
+        expression: string;
+    }>>;
+    unknown: string[];
+}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "@svelte-lean/vite",
+  "version": "0.1.0",
+  "description": "Vite integration for Svelte Lean: discovers data-slean behaviors in Svelte markup at build time and injects only the registration modules that are used.",
+  "license": "MIT",
+  "author": "Ömer Say",
+  "type": "module",
+  "engines": {
+    "node": "^20.19.0 || >=22.12.0"
+  },
+  "sideEffects": false,
+  "files": [
+    "dist"
+  ],
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "node -e \"require('node:fs').rmSync('dist', { recursive: true, force: true })\" && yarn run -T tsc -p tsconfig.build.json && yarn run -T publint",
+    "check": "yarn run -T tsc -p tsconfig.json --noEmit",
+    "test": "yarn run -T vitest run"
+  },
+  "peerDependencies": {
+    "@svelte-lean/primitives": "^0.1.0",
+    "vite": "^6.0.0 || ^7.0.0 || ^8.0.0"
+  },
+  "peerDependenciesMeta": {
+    "@svelte-lean/primitives": {
+      "optional": true
+    }
+  },
+  "homepage": "https://svelte-lean.vercel.app/docs/architecture/build-time-discovery",
+  "bugs": {
+    "url": "https://github.com/say16/svelte-lean/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/say16/svelte-lean.git",
+    "directory": "packages/vite"
+  },
+  "keywords": [
+    "vite",
+    "vite-plugin",
+    "svelte",
+    "svelte5",
+    "svelte-lean",
+    "sveltekit",
+    "tree-shaking",
+    "code-splitting"
+  ]
+}