svelte-origin 0.0.0 → 1.0.0-next.15

package/dist/vite-dts.js

@@ -0,0 +1,606 @@
+// src/vite-dts.ts
+import { existsSync } from "node:fs";
+import { writeFile, readFile, unlink } from "node:fs/promises";
+import { dirname, join } from "node:path";
+
+// src/transform/patterns.ts
+var patterns = {
+  hasMacros: /\$origin|\$attrs\.(origin|for)|\$attrs\s*\(/,
+  origin: /\$origin\s*\(/g,
+  originWithParents: /\$origin\s*\(\s*\[/,
+  attrsInOrigin: /\$attrs\s*\(\s*\{/g,
+  standaloneAttrs: /(?:let|const|export\s+const|export\s+let)\s+\w+\s*=\s*\$attrs\s*\(/g,
+  bindableInAttrs: /\$bindable\s*\(/g,
+  attrsOrigin: /\$attrs\s*\.\s*origin\s*\(\s*(\w+)\s*\)/g,
+  attrsForOrigin: /\$attrs\s*\.\s*for\s*\(\s*(\w+)\s*\)/g,
+  attrsForElement: /\$attrs\s*\.\s*for\s*\(\s*['"]([\w-]+)['"]\s*\)/g
+};
+function containsMacros(source) {
+  return patterns.hasMacros.test(source);
+}
+function isInsideStringOrComment(source, position) {
+  let i = 0;
+  while (i < position) {
+    const char = source[i];
+    if (char === "/" && source[i + 1] === "/") {
+      const endLine = source.indexOf(`
+`, i + 2);
+      if (endLine === -1) {
+        return position > i;
+      }
+      if (position > i && position <= endLine) {
+        return true;
+      }
+      i = endLine + 1;
+      continue;
+    }
+    if (char === "/" && source[i + 1] === "*") {
+      const endComment = source.indexOf("*/", i + 2);
+      if (endComment === -1) {
+        return position > i;
+      }
+      if (position > i && position < endComment + 2) {
+        return true;
+      }
+      i = endComment + 2;
+      continue;
+    }
+    if (char === '"' || char === "'" || char === "`") {
+      const quote = char;
+      const stringStart = i;
+      i++;
+      while (i < source.length) {
+        if (source[i] === "\\") {
+          i += 2;
+          continue;
+        }
+        if (source[i] === quote) {
+          if (position > stringStart && position <= i) {
+            return true;
+          }
+          i++;
+          break;
+        }
+        if (quote === "`" && source[i] === "$" && source[i + 1] === "{") {
+          const exprStart = i;
+          i += 2;
+          let depth = 1;
+          while (i < source.length && depth > 0) {
+            if (source[i] === "{")
+              depth++;
+            else if (source[i] === "}")
+              depth--;
+            else if (source[i] === "\\")
+              i++;
+            i++;
+          }
+          if (position > stringStart && position < exprStart) {
+            return true;
+          }
+          continue;
+        }
+        i++;
+      }
+      continue;
+    }
+    i++;
+  }
+  return false;
+}
+function extractBindable(value) {
+  if (!value.startsWith("$bindable"))
+    return { isBindable: false };
+  let i = 9;
+  if (value[i] === "<") {
+    let depth = 1;
+    i++;
+    while (i < value.length && depth > 0) {
+      const char = value[i];
+      if (char === "=" && value[i + 1] === ">") {
+        i += 2;
+        continue;
+      }
+      if (char === "<")
+        depth++;
+      else if (char === ">")
+        depth--;
+      i++;
+    }
+  }
+  while (i < value.length && /\s/.test(value[i]))
+    i++;
+  if (value[i] !== "(")
+    return { isBindable: false };
+  const openParen = i;
+  const closeParen = findMatchingBracket(value, openParen);
+  if (closeParen === -1)
+    return { isBindable: false };
+  const innerValue = value.slice(openParen + 1, closeParen).trim() || "undefined";
+  return { isBindable: true, innerValue };
+}
+function findTopLevelAs(value) {
+  let depth = 0;
+  let angleDepth = 0;
+  for (let i = 0;i < value.length - 4; i++) {
+    const char = value[i];
+    if (char === '"' || char === "'" || char === "`") {
+      const quote = char;
+      i++;
+      while (i < value.length && value[i] !== quote) {
+        if (value[i] === "\\")
+          i++;
+        i++;
+      }
+      continue;
+    }
+    if (char === "{" || char === "(" || char === "[") {
+      depth++;
+    } else if (char === "}" || char === ")" || char === "]") {
+      depth--;
+    } else if (char === "<") {
+      const prevChar = i > 0 ? value[i - 1] : "";
+      if (/[\w$)]/.test(prevChar)) {
+        angleDepth++;
+      }
+    } else if (char === ">") {
+      if (i > 0 && value[i - 1] === "=") {
+        continue;
+      }
+      if (angleDepth > 0) {
+        angleDepth--;
+      }
+    } else if (depth === 0 && angleDepth === 0 && value.slice(i, i + 4) === " as ") {
+      return i;
+    }
+  }
+  return -1;
+}
+function findMatchingBracket(source, openIndex, openChar = "(", closeChar = ")") {
+  let depth = 0;
+  for (let i = openIndex;i < source.length; i++) {
+    const char = source[i];
+    if (char === "/" && source[i + 1] === "/") {
+      const endLine = source.indexOf(`
+`, i + 2);
+      if (endLine !== -1) {
+        i = endLine;
+      } else {
+        i = source.length;
+      }
+      continue;
+    }
+    if (char === "/" && source[i + 1] === "*") {
+      const endComment = source.indexOf("*/", i + 2);
+      if (endComment !== -1) {
+        i = endComment + 1;
+      } else {
+        i = source.length;
+      }
+      continue;
+    }
+    if (char === '"' || char === "'" || char === "`") {
+      const quote = char;
+      i++;
+      while (i < source.length && source[i] !== quote) {
+        if (source[i] === "\\")
+          i++;
+        i++;
+      }
+      continue;
+    }
+    if (char === openChar) {
+      depth++;
+    } else if (char === closeChar) {
+      depth--;
+      if (depth === 0) {
+        return i;
+      }
+    }
+  }
+  return -1;
+}
+
+// src/transform/schema.ts
+function parseOriginSchemaFromSource(source, exportName) {
+  const exportPattern = new RegExp(`export\\s+const\\s+${exportName}\\s*=\\s*\\$origin\\s*\\(`, "s");
+  const match = exportPattern.exec(source);
+  if (!match)
+    return null;
+  const originStart = match.index + match[0].length - 1;
+  const originEnd = findMatchingBracket(source, originStart);
+  if (originEnd === -1)
+    return null;
+  const originContent = source.slice(originStart + 1, originEnd);
+  let parentNames = [];
+  let bodyContent = originContent.trim();
+  if (bodyContent.startsWith("[")) {
+    const closeBracket = findMatchingBracket(bodyContent, 0, "[", "]");
+    if (closeBracket !== -1) {
+      const parentsContent = bodyContent.slice(1, closeBracket);
+      parentNames = parentsContent.split(",").map((p) => p.trim()).filter((p) => p && /^\w+$/.test(p));
+      let i = closeBracket + 1;
+      while (i < bodyContent.length && /[\s,]/.test(bodyContent[i]))
+        i++;
+      bodyContent = bodyContent.slice(i);
+    }
+  }
+  const attrsMatch = bodyContent.match(/(\w+)\s*:\s*\$attrs\s*\(\s*\{/);
+  if (!attrsMatch) {
+    return { attrs: [], parentNames };
+  }
+  const attrsStart = attrsMatch.index;
+  const attrsObjStart = bodyContent.indexOf("{", attrsStart + attrsMatch[0].length - 1);
+  const attrsObjEnd = findMatchingBracket(bodyContent, attrsObjStart, "{", "}");
+  if (attrsObjEnd === -1) {
+    return { attrs: [], parentNames };
+  }
+  const attrsContent = bodyContent.slice(attrsObjStart + 1, attrsObjEnd);
+  const attrs = parseAttrsContent(attrsContent);
+  return { attrs, parentNames };
+}
+function parseAttrsContent(content) {
+  const result = [];
+  const parts = splitByTopLevelCommas(content);
+  for (const part of parts) {
+    let trimmed = part.trim();
+    if (!trimmed)
+      continue;
+    trimmed = stripComments(trimmed);
+    if (!trimmed)
+      continue;
+    const colonIndex = trimmed.indexOf(":");
+    if (colonIndex === -1)
+      continue;
+    const key = trimmed.slice(0, colonIndex).trim();
+    let value = trimmed.slice(colonIndex + 1).trim();
+    const asIndex = findTopLevelAs(value);
+    if (asIndex !== -1) {
+      value = value.slice(0, asIndex).trim();
+    }
+    const bindableResult = extractBindable(value);
+    if (bindableResult.isBindable) {
+      const defaultVal = bindableResult.innerValue;
+      const hasDefault = defaultVal !== "" && defaultVal !== "undefined";
+      result.push({
+        key,
+        defaultValue: defaultVal,
+        bindable: true,
+        hasDefault
+      });
+    } else {
+      const hasDefault = value !== "undefined";
+      result.push({
+        key,
+        defaultValue: value,
+        bindable: false,
+        hasDefault
+      });
+    }
+  }
+  return result;
+}
+function splitByTopLevelCommas(source) {
+  const parts = [];
+  let current = "";
+  let depth = 0;
+  let angleDepth = 0;
+  for (let i = 0;i < source.length; i++) {
+    const char = source[i];
+    if (char === '"' || char === "'" || char === "`") {
+      const quote = char;
+      current += char;
+      i++;
+      while (i < source.length && source[i] !== quote) {
+        if (source[i] === "\\") {
+          current += source[i];
+          i++;
+        }
+        if (i < source.length) {
+          current += source[i];
+          i++;
+        }
+      }
+      if (i < source.length) {
+        current += source[i];
+      }
+      continue;
+    }
+    if (char === "<") {
+      const prevChar = current.length > 0 ? current[current.length - 1] : "";
+      if (/[\w$)]/.test(prevChar)) {
+        angleDepth++;
+      }
+      current += char;
+    } else if (char === ">") {
+      if (current.length > 0 && current[current.length - 1] === "=") {
+        current += char;
+        continue;
+      }
+      if (angleDepth > 0) {
+        angleDepth--;
+      }
+      current += char;
+    } else if (char === "{" || char === "(" || char === "[") {
+      depth++;
+      current += char;
+    } else if (char === "}" || char === ")" || char === "]") {
+      depth--;
+      current += char;
+    } else if (char === "," && depth === 0 && angleDepth === 0) {
+      parts.push(current);
+      current = "";
+    } else {
+      current += char;
+    }
+  }
+  if (current.trim()) {
+    parts.push(current);
+  }
+  return parts;
+}
+function stripComments(str) {
+  let result = str.trim();
+  while (result.startsWith("/*")) {
+    const endComment = result.indexOf("*/");
+    if (endComment !== -1) {
+      result = result.slice(endComment + 2).trim();
+    } else {
+      break;
+    }
+  }
+  while (result.startsWith("//")) {
+    const endLine = result.indexOf(`
+`);
+    if (endLine !== -1) {
+      result = result.slice(endLine + 1).trim();
+    } else {
+      result = "";
+      break;
+    }
+  }
+  return result;
+}
+function generatePropsDestructuring(attrs, factoryName) {
+  const parts = [];
+  for (const attr of attrs) {
+    if (attr.bindable) {
+      if (attr.hasDefault) {
+        parts.push(`${attr.key} = $bindable(${attr.defaultValue})`);
+      } else {
+        parts.push(`${attr.key} = $bindable()`);
+      }
+    } else if (attr.hasDefault) {
+      parts.push(`${attr.key} = ${attr.defaultValue}`);
+    } else {
+      parts.push(attr.key);
+    }
+  }
+  return `let { ${parts.join(", ")} }: $attrs.Of<typeof ${factoryName}> = $props()`;
+}
+function generateFactoryCallFromAttrs(factoryName, attrs) {
+  const parts = [];
+  for (const attr of attrs) {
+    parts.push(`get ${attr.key}() { return ${attr.key} }`);
+    if (attr.bindable) {
+      parts.push(`set ${attr.key}(v) { ${attr.key} = v }`);
+    }
+  }
+  return `${factoryName}({ ${parts.join(", ")} })`;
+}
+function findImportPath(source, identifier) {
+  const patterns2 = [
+    new RegExp(`import\\s*\\{[^}]*\\b${identifier}\\b[^}]*\\}\\s*from\\s*['"]([^'"]+)['"]`),
+    new RegExp(`import\\s*\\{[^}]*\\bas\\s+${identifier}\\b[^}]*\\}\\s*from\\s*['"]([^'"]+)['"]`),
+    new RegExp(`import\\s+${identifier}\\s+from\\s*['"]([^'"]+)['"]`),
+    new RegExp(`import\\s*\\*\\s*as\\s+${identifier}\\s+from\\s*['"]([^'"]+)['"]`)
+  ];
+  for (const pattern of patterns2) {
+    const match = pattern.exec(source);
+    if (match) {
+      return match[1];
+    }
+  }
+  return null;
+}
+function generatePropsInterface(schema) {
+  const lines = [];
+  const bindings = [];
+  for (const attr of schema.attrs) {
+    const type = inferTypeFromDefault(attr.defaultValue);
+    const optional = attr.hasDefault ? "?" : "";
+    lines.push(`${attr.key}${optional}: ${type}`);
+    if (attr.bindable) {
+      bindings.push(attr.key);
+    }
+  }
+  const interfaceContent = lines.length > 0 ? `{ ${lines.join("; ")} }` : "{}";
+  return { interfaceContent, bindings };
+}
+function inferTypeFromDefault(defaultValue) {
+  if (defaultValue === "undefined")
+    return "unknown";
+  if (defaultValue === "true" || defaultValue === "false")
+    return "boolean";
+  if (/^-?\d+$/.test(defaultValue))
+    return "number";
+  if (/^-?\d+\.\d+$/.test(defaultValue))
+    return "number";
+  if (/^['"]/.test(defaultValue))
+    return "string";
+  if (defaultValue.startsWith("["))
+    return "unknown[]";
+  if (defaultValue.startsWith("{"))
+    return "Record<string, unknown>";
+  if (defaultValue === "null")
+    return "null";
+  return "unknown";
+}
+function generateDtsContent(factoryName, importPath, schema, comment = "regenerated on save") {
+  const propsLines = [];
+  const bindableProps = [];
+  for (const attr of schema.attrs) {
+    const type = inferTypeFromDefault(attr.defaultValue);
+    const optional = attr.hasDefault ? "?" : "";
+    propsLines.push(`    ${attr.key}${optional}: ${type};`);
+    if (attr.bindable) {
+      bindableProps.push(`"${attr.key}"`);
+    }
+  }
+  const propsType = propsLines.length > 0 ? `{
+${propsLines.join(`
+`)}
+}` : "{}";
+  const bindingsType = bindableProps.length > 0 ? bindableProps.join(" | ") : "never";
+  return `// Auto-generated by svelte-origin
+// Do not edit manually - ${comment}
+
+import type { Component } from 'svelte';
+import type { ${factoryName} } from '${importPath}';
+
+/**
+ * Props derived from ${factoryName} origin factory.
+ * 
+ * Bindable props: ${bindableProps.length > 0 ? bindableProps.join(", ") : "none"}
+ */
+type Props = ${propsType};
+
+declare const __component: Component<Props, {}, ${bindingsType}>;
+export default __component;
+`;
+}
+
+// src/vite-dts.ts
+function svelteOriginDts(options = {}) {
+  const { debug = false } = options;
+  const schemaCache = new Map;
+  return {
+    name: "svelte-origin-dts",
+    enforce: "pre",
+    async transform(code, id) {
+      if (!id.endsWith(".svelte"))
+        return null;
+      const originMatch = code.match(/\$attrs\s*\.\s*origin\s*\(\s*(\w+)\s*\)/);
+      if (!originMatch)
+        return null;
+      const factoryName = originMatch[1];
+      if (debug) {
+        console.log(`[svelte-origin-dts] Found $attrs.origin(${factoryName}) in ${id}`);
+      }
+      const importPath = findImportPath(code, factoryName);
+      if (!importPath) {
+        if (debug) {
+          console.log(`[svelte-origin-dts] Could not find import for ${factoryName}`);
+        }
+        return null;
+      }
+      const schema = await resolveSchema(id, importPath, factoryName, schemaCache, debug);
+      if (!schema || schema.attrs.length === 0) {
+        if (debug) {
+          console.log(`[svelte-origin-dts] No schema found for ${factoryName}`);
+        }
+        return null;
+      }
+      const dtsContent = generateDtsContent(factoryName, importPath, schema);
+      const dtsPath = id + ".d.ts";
+      await writeFile(dtsPath, dtsContent, "utf-8");
+      if (debug) {
+        console.log(`[svelte-origin-dts] Generated ${dtsPath}`);
+      }
+      return null;
+    },
+    async handleHotUpdate({ file }) {
+      if (file.endsWith(".svelte")) {
+        const dtsPath = file + ".d.ts";
+        if (!existsSync(file) && existsSync(dtsPath)) {
+          await unlink(dtsPath);
+        }
+      }
+    }
+  };
+}
+async function resolveSchema(importerPath, importPath, factoryName, cache, debug) {
+  const cacheKey = `${importPath}::${factoryName}`;
+  if (cache.has(cacheKey)) {
+    return cache.get(cacheKey) || null;
+  }
+  try {
+    const importerDir = dirname(importerPath);
+    let resolvedPath;
+    if (importPath.startsWith(".")) {
+      resolvedPath = join(importerDir, importPath);
+    } else {
+      cache.set(cacheKey, null);
+      return null;
+    }
+    const extensions = [".ts", ".svelte.ts", ".svelte.js", ".js"];
+    let filePath = resolvedPath;
+    if (!existsSync(filePath)) {
+      if (resolvedPath.endsWith(".svelte")) {
+        const svelteTs = resolvedPath + ".ts";
+        if (existsSync(svelteTs)) {
+          filePath = svelteTs;
+        }
+      }
+      if (!existsSync(filePath)) {
+        for (const ext of extensions) {
+          const candidate = resolvedPath + ext;
+          if (existsSync(candidate)) {
+            filePath = candidate;
+            break;
+          }
+        }
+      }
+    }
+    if (!existsSync(filePath)) {
+      cache.set(cacheKey, null);
+      return null;
+    }
+    const source = await readFile(filePath, "utf-8");
+    const schema = parseOriginSchemaFromSource(source, factoryName);
+    if (!schema) {
+      cache.set(cacheKey, null);
+      return null;
+    }
+    if (schema.parentNames.length > 0) {
+      const mergedAttrs = [];
+      for (const parentName of schema.parentNames) {
+        const parentImportPath = findImportPath(source, parentName);
+        if (parentImportPath) {
+          const parentSchema = await resolveSchema(filePath, parentImportPath, parentName, cache, debug);
+          if (parentSchema) {
+            for (const attr of parentSchema.attrs) {
+              const existing = mergedAttrs.findIndex((a) => a.key === attr.key);
+              if (existing === -1) {
+                mergedAttrs.push(attr);
+              }
+            }
+          }
+        }
+      }
+      for (const attr of schema.attrs) {
+        const existing = mergedAttrs.findIndex((a) => a.key === attr.key);
+        if (existing !== -1) {
+          mergedAttrs[existing] = attr;
+        } else {
+          mergedAttrs.push(attr);
+        }
+      }
+      const mergedSchema = { attrs: mergedAttrs, parentNames: schema.parentNames };
+      cache.set(cacheKey, mergedSchema);
+      return mergedSchema;
+    }
+    cache.set(cacheKey, schema);
+    return schema;
+  } catch (error) {
+    if (debug) {
+      console.error(`[svelte-origin-dts] Error resolving ${importPath}:`, error);
+    }
+    cache.set(cacheKey, null);
+    return null;
+  }
+}
+var vite_dts_default = svelteOriginDts;
+export {
+  svelteOriginDts,
+  vite_dts_default as default
+};

package/package.json

@@ -1,4 +1,74 @@
-{
-	"name": "svelte-origin",
-	"version": "0.0.0"
+{
+	"name": "svelte-origin",
+	"version": "1.0.0-next.15",
+	"description": "Compiler-assisted state and prop ergonomics for Svelte 5",
+	"main": "dist/index.js",
+	"types": "dist/index.d.ts",
+	"type": "module",
+	"bin": {
+		"svelte-origin": "./dist/cli.js"
+	},
+	"files": [
+		"README.md",
+		"LLM.md",
+		"dist"
+	],
+	"exports": {
+		".": {
+			"types": "./dist/index.d.ts",
+			"import": "./dist/index.js"
+		},
+		"./runtime": {
+			"types": "./dist/runtime/index.d.ts",
+			"import": "./dist/runtime/index.js"
+		},
+		"./plugin": {
+			"types": "./dist/plugin.d.ts",
+			"import": "./dist/plugin.js"
+		},
+		"./preprocess": {
+			"types": "./dist/preprocess.d.ts",
+			"import": "./dist/preprocess.js"
+		},
+		"./vite-dts": {
+			"types": "./dist/vite-dts.d.ts",
+			"import": "./dist/vite-dts.js"
+		},
+		"./post-process": {
+			"types": "./dist/post-process.d.ts",
+			"import": "./dist/post-process.js"
+		},
+		"./globals": "./dist/globals.d.ts"
+	},
+	"scripts": {
+		"build": "bun run build:types && bun run build:globals && bun run build:esm",
+		"build:esm": "bun build src/index.ts src/plugin.ts src/preprocess.ts src/vite-dts.ts src/cli.ts src/post-process.ts src/runtime/index.ts --outdir dist --format esm --external node:fs --external node:path --external node:fs/promises --target node",
+		"build:types": "tsc --project tsconfig.build.json",
+		"build:globals": "bun -e \"require('fs').copyFileSync('src/globals.d.ts', 'dist/globals.d.ts')\"",
+		"test": "vitest run",
+		"test:watch": "vitest",
+		"typecheck": "tsc --noEmit"
+	},
+	"peerDependencies": {
+		"svelte": "^5.0.0"
+	},
+	"peerDependenciesMeta": {
+		"vite": {
+			"optional": true
+		}
+	},
+	"dependencies": {
+		"magic-string": "^0.30.0"
+	},
+	"devDependencies": {
+		"@sveltejs/vite-plugin-svelte": "^5.0.0",
+		"@testing-library/svelte": "^5.0.0",
+		"bun-types": "latest",
+		"jsdom": "^25.0.0",
+		"svelte": "^5.0.0",
+		"svelte2tsx": "^0.7.45",
+		"typescript": "^5.0.0",
+		"vite": "^6.0.0",
+		"vitest": "^2.0.0"
+	}
 }