@poveste/plugin-svelte 0.9.0 → 0.11.0

package/dist/index.node.js

@@ -3,13 +3,15 @@ import { createRequire } from 'node:module';
 import { dirname, join } from 'pathe';
 import { defaultColors } from 'poveste';
 import generateStoryCommand from './commands/generate-story.server.js';
+import { svelteKitAssetsDir } from './util/kit-assets.js';
 import { listComponentFiles } from './util/list-components.js';
 import { disableStoryComponentHmr } from './util/story-hmr.js';
 export function HstSvelte() {
     return {
         name: '@poveste/plugin-svelte',
-        defaultConfig() {
+        async defaultConfig() {
             const svelteClientAliases = getSvelteClientAliases();
+            const publicDir = await svelteKitAssetsDir(process.cwd());
             return {
                 supportMatch: [
                     {
@@ -31,20 +33,13 @@ export function HstSvelte() {
                 viteIgnorePlugins: [
                     'vite-plugin-sveltekit-compile',
                 ],
-                vite: svelteClientAliases.length
-                    ? {
-                        plugins: [
-                            disableStoryComponentHmr(),
-                        ],
-                        resolve: {
-                            alias: svelteClientAliases,
-                        },
-                    }
-                    : {
-                        plugins: [
-                            disableStoryComponentHmr(),
-                        ],
-                    },
+                vite: {
+                    plugins: [
+                        disableStoryComponentHmr(),
+                    ],
+                    ...svelteClientAliases.length ? { resolve: { alias: svelteClientAliases } } : {},
+                    ...publicDir ? { publicDir } : {},
+                },
             };
         },
         supportPlugin: {

package/dist/util/kit-assets.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Where a SvelteKit project keeps its static assets, or undefined when this is
+ * not one.
+ *
+ * `vite-plugin-sveltekit-compile` is what sets Vite's `publicDir` to
+ * `kit.files.assets`, and poveste drops that plugin through `viteIgnorePlugins`
+ * — so a book served none of a Kit project's `static/`, in dev or in the build
+ * (#463). This restores the one value that went with it.
+ */
+export declare function svelteKitAssetsDir(cwd: string): Promise<string | undefined>;

package/dist/util/kit-assets.js

@@ -0,0 +1,51 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { pathToFileURL } from 'node:url';
+import { isAbsolute, join } from 'pathe';
+/**
+ * Where a SvelteKit project keeps its static assets, or undefined when this is
+ * not one.
+ *
+ * `vite-plugin-sveltekit-compile` is what sets Vite's `publicDir` to
+ * `kit.files.assets`, and poveste drops that plugin through `viteIgnorePlugins`
+ * — so a book served none of a Kit project's `static/`, in dev or in the build
+ * (#463). This restores the one value that went with it.
+ */
+export async function svelteKitAssetsDir(cwd) {
+    if (!declaresKit(cwd)) {
+        return undefined;
+    }
+    const assets = await configuredAssetsDir(cwd) ?? 'static';
+    return isAbsolute(assets) ? assets : join(cwd, assets);
+}
+// The project's own manifest, not `require.resolve`: resolution walks up out of
+// the project and finds Kit through a sibling in a workspace store, which
+// reported a plain Svelte book as SvelteKit and pointed its `publicDir` at a
+// `static/` that does not exist — losing the `public/` it actually had.
+function declaresKit(cwd) {
+    try {
+        const manifest = JSON.parse(readFileSync(join(cwd, 'package.json'), 'utf8'));
+        return ['dependencies', 'devDependencies', 'peerDependencies']
+            .some(field => manifest[field]?.['@sveltejs/kit']);
+    }
+    catch {
+        return false;
+    }
+}
+// Kit reads this from `svelte.config.js` and defaults it to `static`. Reading it
+// rather than assuming the default is what makes a project that moved its assets
+// work; a config that will not load is not this plugin's failure to report, so
+// the default stands in.
+async function configuredAssetsDir(cwd) {
+    const configPath = join(cwd, 'svelte.config.js');
+    if (!existsSync(configPath)) {
+        return undefined;
+    }
+    try {
+        const loaded = await import(pathToFileURL(configPath).href);
+        const assets = loaded.default?.kit?.files?.assets;
+        return typeof assets === 'string' ? assets : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/util/props.d.ts

@@ -0,0 +1,3 @@
+import type { PropDefinition } from '@poveste/shared';
+/** The props declared, or `undefined` when the source could not be read. */
+export declare function extractPropDefs(source: string): PropDefinition[] | undefined;

package/dist/util/props.js

@@ -0,0 +1,279 @@
+// A compiled Svelte component keeps no record of what it accepts, the way a Vue
+// vnode does, so the source is the only place its props still exist (#233).
+import { parse } from 'svelte/compiler';
+// Poveste injects this into every story file; no user sets it.
+const INJECTED = 'Hst';
+const SCRIPT_BLOCK = /<script[^>]*>[\s\S]*?<\/script>/gi;
+// Line-anchored: a mention in a comment must not start a match.
+const TYPE_IMPORT = /^[ \t]*import\s+type\b[^;]+?\bfrom[ \t]*(['"])[^'"]*\1(?:[ \t]*;)?[ \t]*$/gm;
+const IMPORT_BRACES = /\bimport\s*\{([^}]*)\}/g;
+// Script blocks only: props live nowhere else, and a preprocessed `<style>`
+// never reaches the parser to throw. Type-only imports still go, both spellings
+// — `import type { Hst }` beside `export let Hst: Hst` reads as a redeclaration.
+function parseable(source) {
+    return (source.match(SCRIPT_BLOCK) ?? [])
+        .join('\n')
+        .replace(TYPE_IMPORT, '')
+        .replace(IMPORT_BRACES, (_, specifiers) => {
+        const kept = specifiers.split(',').map(s => s.trim()).filter(s => s && !/^type\s/.test(s));
+        return `import { ${kept.join(', ')} }`;
+    });
+}
+function nameOf(typeName) {
+    return typeName?.name ?? typeName?.right?.name;
+}
+function withoutNullish(types) {
+    return types.filter((m) => m.type !== 'TSUndefinedKeyword' && m.type !== 'TSNullKeyword');
+}
+// Slot content, which no control can author. Function props are kept — Vue's
+// auto-props lists them too.
+function isSnippet(node) {
+    if (!node) {
+        return false;
+    }
+    if (node.type === 'TSParenthesizedType') {
+        return isSnippet(node.typeAnnotation);
+    }
+    if (node.type === 'TSUnionType') {
+        const real = withoutNullish(node.types);
+        return real.length > 0 && real.every((m) => isSnippet(m));
+    }
+    return nameOf(node.typeName) === 'Snippet';
+}
+// Only `undefined` makes a prop omittable; `string | null` still has to be passed.
+function acceptsUndefined(node) {
+    if (node?.type === 'TSParenthesizedType') {
+        return acceptsUndefined(node.typeAnnotation);
+    }
+    return node?.type === 'TSUnionType'
+        && node.types.some((m) => m.type === 'TSUndefinedKeyword');
+}
+function typesFromAnnotation(node) {
+    if (!node) {
+        return undefined;
+    }
+    switch (node.type) {
+        case 'TSStringKeyword': return ['string'];
+        case 'TSNumberKeyword': return ['number'];
+        case 'TSBooleanKeyword': return ['boolean'];
+        case 'TSArrayType':
+        case 'TSTupleType': return ['array'];
+        case 'TSTypeOperator':
+        case 'TSParenthesizedType': return typesFromAnnotation(node.typeAnnotation);
+        case 'TSTypeLiteral': return ['object'];
+        case 'TSLiteralType': return [typeName(literalValue(node.literal))];
+        case 'TSUnionType': return unionTypes(node);
+        case 'TSTypeReference':
+            return ['Array', 'ReadonlyArray'].includes(nameOf(node.typeName) ?? '') ? ['array'] : ['unknown'];
+        default: return ['unknown'];
+    }
+}
+function typeName(value) {
+    switch (typeof value) {
+        case 'string': return 'string';
+        case 'number': return 'number';
+        case 'boolean': return 'boolean';
+        default: return 'unknown';
+    }
+}
+// `unknown` sorts last because the panel reads `types[0]`, so a concrete type
+// wins however the union was written.
+function unionTypes(node) {
+    const members = withoutNullish(node.types)
+        .flatMap((m) => typesFromAnnotation(m) ?? []);
+    return [...new Set(members)].sort((a, b) => Number(a === 'unknown') - Number(b === 'unknown'));
+}
+function typesFromValue(value) {
+    const name = typeName(value);
+    return name === 'unknown' ? undefined : [name];
+}
+// The only place a definition is built, so the filters cannot be bypassed.
+function propDef(name, annotation, init, optional) {
+    if (name === INJECTED || isSnippet(annotation)) {
+        return undefined;
+    }
+    const value = literalValue(init);
+    return {
+        name,
+        types: typesFromAnnotation(annotation) ?? typesFromValue(value),
+        required: !optional && init == null && !acceptsUndefined(annotation),
+        default: value,
+    };
+}
+function localBindings(body) {
+    const found = new Map();
+    for (const node of body) {
+        const declaration = node.type === 'ExportNamedDeclaration' ? node.declaration : node;
+        if (declaration?.type === 'VariableDeclaration') {
+            for (const declarator of declaration.declarations) {
+                if (declarator.id.type === 'Identifier') {
+                    found.set(declarator.id.name, {
+                        kind: declaration.kind,
+                        annotation: declarator.id.typeAnnotation?.typeAnnotation,
+                        init: declarator.init,
+                    });
+                }
+            }
+        }
+        if (declaration?.type === 'FunctionDeclaration' && declaration.id) {
+            found.set(declaration.id.name, { kind: 'function' });
+        }
+    }
+    return found;
+}
+// `export let x` is a prop, and `export { x as y }` when `x` is a `let`. An
+// accessor, a re-export and a type-only export are not.
+function legacyProps(body) {
+    const props = [];
+    const locals = localBindings(body);
+    for (const node of body) {
+        if (node.type !== 'ExportNamedDeclaration' || node.exportKind === 'type' || node.source) {
+            continue;
+        }
+        if (!node.declaration && node.specifiers?.length) {
+            for (const specifier of node.specifiers) {
+                const local = locals.get(specifier.local?.name);
+                const def = local?.kind === 'let'
+                    ? propDef(specifier.exported?.name, local.annotation, local.init, false)
+                    : undefined;
+                if (def) {
+                    props.push(def);
+                }
+            }
+            continue;
+        }
+        if (node.declaration?.type !== 'VariableDeclaration' || node.declaration.kind !== 'let') {
+            continue;
+        }
+        for (const declarator of node.declaration.declarations) {
+            if (declarator.id.type !== 'Identifier') {
+                continue;
+            }
+            const def = propDef(declarator.id.name, declarator.id.typeAnnotation?.typeAnnotation, declarator.init, false);
+            if (def) {
+                props.push(def);
+            }
+        }
+    }
+    return props;
+}
+function runesProps(body, declared) {
+    const declarator = body
+        .filter((node) => node.type === 'VariableDeclaration')
+        .flatMap((node) => node.declarations)
+        .find((d) => d.init?.type === 'CallExpression' && d.init.callee?.name === '$props');
+    return declarator ? fromDeclarator(declarator, declared) : [];
+}
+function declaredTypes(body) {
+    const found = new Map();
+    for (const node of body) {
+        const declaration = node.type === 'ExportNamedDeclaration' ? node.declaration : node;
+        if (declaration?.type === 'TSInterfaceDeclaration') {
+            found.set(declaration.id.name, { type: 'TSTypeLiteral', members: declaration.body.body });
+        }
+        if (declaration?.type === 'TSTypeAliasDeclaration') {
+            found.set(declaration.id.name, declaration.typeAnnotation);
+        }
+    }
+    return found;
+}
+// An alias may intersect literals and other declared names.
+function membersOf(node, declared, depth = 0) {
+    if (!node || depth > 4) {
+        return undefined;
+    }
+    if (node.type === 'TSTypeLiteral') {
+        return node.members;
+    }
+    if (node.type === 'TSTypeReference') {
+        return membersOf(declared.get(nameOf(node.typeName) ?? ''), declared, depth + 1);
+    }
+    if (node.type === 'TSIntersectionType') {
+        const parts = node.types.flatMap((t) => membersOf(t, declared, depth + 1) ?? []);
+        return parts.length > 0 ? parts : undefined;
+    }
+    return undefined;
+}
+// The annotation and the destructuring each know something the other does not:
+// the annotation carries types and optionality, the destructuring carries
+// defaults and every prop an `extends` clause hides. Merge rather than choose.
+function fromDeclarator(declarator, declared) {
+    const destructured = destructuredDefaults(declarator.id);
+    const members = membersOf(declarator.id.typeAnnotation?.typeAnnotation, declared);
+    const defs = [];
+    const seen = new Set();
+    for (const member of members ?? []) {
+        if (member.key?.type !== 'Identifier') {
+            continue;
+        }
+        // Seen before the kind check, so a method signature is not re-added below.
+        seen.add(member.key.name);
+        if (member.type !== 'TSPropertySignature') {
+            continue;
+        }
+        const def = propDef(member.key.name, member.typeAnnotation?.typeAnnotation, destructured.get(member.key.name), member.optional);
+        if (def) {
+            defs.push(def);
+        }
+    }
+    for (const [name, init] of destructured) {
+        // `children` is the default snippet in runes mode; with no annotation to
+        // read, the name is the only thing that says so.
+        if (seen.has(name) || name === 'children') {
+            continue;
+        }
+        // Unannotated, the destructuring is the only signal; annotated, an
+        // inherited prop's optionality is unknowable.
+        const def = propDef(name, undefined, init, members !== undefined);
+        if (def) {
+            defs.push(def);
+        }
+    }
+    return defs;
+}
+function destructuredDefaults(id) {
+    const found = new Map();
+    if (id.type !== 'ObjectPattern') {
+        return found;
+    }
+    for (const property of id.properties) {
+        if (property.type !== 'Property' || property.computed || property.key.type !== 'Identifier') {
+            continue;
+        }
+        found.set(property.key.name, property.value.type === 'AssignmentPattern' ? property.value.right : undefined);
+    }
+    return found;
+}
+// Only what a control can hold and JSON can carry. A `$bindable` default is one
+// node deeper.
+function literalValue(node) {
+    if (!node) {
+        return undefined;
+    }
+    if (node.type === 'CallExpression' && node.callee?.name === '$bindable') {
+        return literalValue(node.arguments?.[0]);
+    }
+    if (node.type === 'UnaryExpression' && node.operator === '-') {
+        const inner = literalValue(node.argument);
+        return typeof inner === 'number' ? -inner : undefined;
+    }
+    if (node.type !== 'Literal') {
+        return undefined;
+    }
+    return typeof node.value === 'bigint' || node.value instanceof RegExp ? undefined : node.value;
+}
+/** The props declared, or `undefined` when the source could not be read. */
+export function extractPropDefs(source) {
+    let ast;
+    try {
+        ast = parse(parseable(source), { modern: true });
+    }
+    catch {
+        return undefined;
+    }
+    // Types may be declared in the module script; props never are.
+    const body = ast.instance?.content?.body ?? [];
+    const declared = declaredTypes([...(ast.module?.content?.body ?? []), ...body]);
+    const runes = runesProps(body, declared);
+    return runes.length > 0 ? runes : legacyProps(body);
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@poveste/plugin-svelte",
   "type": "module",
-  "version": "0.9.0",
+  "version": "0.11.0",
   "description": "Poveste plugin for Svelte 5 and SvelteKit support",
   "author": {
     "name": "Sorin Gitlan"
@@ -60,7 +60,7 @@
     "@sveltejs/kit": "^2.53.0",
     "@sveltejs/vite-plugin-svelte": "^7.0.0",
     "svelte": "^5.46.4",
-    "poveste": "^0.9.0"
+    "poveste": "^0.11.0"
   },
   "peerDependenciesMeta": {
     "@sveltejs/kit": {
@@ -72,9 +72,9 @@
     "globby": "^14.0.2",
     "launch-editor": "^2.9.1",
     "pathe": "^1.1.2",
-    "@poveste/controls": "^0.9.0",
-    "@poveste/shared": "^0.9.0",
-    "@poveste/vendors": "^0.9.0"
+    "@poveste/controls": "^0.11.0",
+    "@poveste/shared": "^0.11.0",
+    "@poveste/vendors": "^0.11.0"
   },
   "devDependencies": {
     "@sveltejs/vite-plugin-svelte": "^7.0.0",
@@ -86,11 +86,14 @@
     "svelte-preprocess": "^6.0.3",
     "typescript": "5.6.3",
     "vite": "^8.0.0",
-    "poveste": "0.9.0"
+    "vitest": "^4.1.10",
+    "poveste": "0.11.0"
   },
   "scripts": {
     "build": "rimraf dist && vite build && tsc -d -P tsconfig.build.json && pnpm run build:types",
     "build:types": "tsc --declaration --emitDeclarationOnly",
+    "test": "vitest run",
+    "test:dev": "vitest",
     "watch": "concurrently \"vite build --watch\" \"tsc -d -P tsconfig.build.json --watch\" \"pnpm run build:types --watch\""
   }
 }