svelte-origin 0.0.0 → 1.0.0-next.15

package/dist/transform/patterns.d.ts

@@ -0,0 +1,82 @@
+/**
+ * Pattern matching utilities for svelte-origin macros
+ */
+/**
+ * Patterns for detecting macro usage in source code
+ */
+export declare const patterns: {
+    /** Quick check if file might contain our macros */
+    hasMacros: RegExp;
+    /** Match $origin(...) call */
+    origin: RegExp;
+    /** Match $origin([...], {...}) with parents */
+    originWithParents: RegExp;
+    /** Match $attrs({...}) inside origin definition */
+    attrsInOrigin: RegExp;
+    /** Match standalone $attrs({...}) or $attrs([...], {...}) */
+    standaloneAttrs: RegExp;
+    /** Match $bindable(...) inside attrs */
+    bindableInAttrs: RegExp;
+    /** Match $attrs.origin(X) */
+    attrsOrigin: RegExp;
+    /** Match $attrs.for(X) where X is an identifier (origin factory) */
+    attrsForOrigin: RegExp;
+    /** Match $attrs.for('x') where x is a string (element name) */
+    attrsForElement: RegExp;
+};
+/**
+ * Check if source code contains any svelte-origin macros
+ */
+export declare function containsMacros(source: string): boolean;
+/**
+ * Find all $origin(...) calls in source
+ */
+export declare function findOriginCalls(source: string): RegExpExecArray[];
+/**
+ * Find all $attrs.origin(X) calls in source
+ */
+export declare function findAttrsOriginCalls(source: string): {
+    name: string;
+    index: number;
+    length: number;
+}[];
+/**
+ * Find all $attrs.for(X) calls in source where X is an origin factory
+ */
+export declare function findAttrsForOriginCalls(source: string): {
+    name: string;
+    index: number;
+    length: number;
+}[];
+/**
+ * Find all $attrs.for('x') calls in source where x is an element name
+ */
+export declare function findAttrsForElementCalls(source: string): {
+    element: string;
+    index: number;
+    length: number;
+}[];
+/**
+ * Check if a position in the source is inside a string literal or comment.
+ * This is used to avoid transforming macro-like syntax that appears inside strings/comments.
+ */
+export declare function isInsideStringOrComment(source: string, position: number): boolean;
+/**
+ * Extract $bindable from a value string, handling nested generics.
+ * Returns { isBindable: true, innerValue: '...' } or { isBindable: false }
+ */
+export declare function extractBindable(value: string): {
+    isBindable: true;
+    innerValue: string;
+} | {
+    isBindable: false;
+};
+/**
+ * Find the position of ' as ' that's not inside nested structures.
+ * Properly handles angle brackets for generics.
+ */
+export declare function findTopLevelAs(value: string): number;
+/**
+ * Find the matching closing bracket for an opening bracket
+ */
+export declare function findMatchingBracket(source: string, openIndex: number, openChar?: string, closeChar?: string): number;

package/dist/transform/schema.d.ts

@@ -0,0 +1,116 @@
+/**
+ * Schema resolution utilities for svelte-origin
+ *
+ * This module handles static extraction of attr schemas from origin source files.
+ * Used by the Vite plugin and preprocessor to enable proper $bindable() expansion.
+ */
+/**
+ * Parsed attr info from source
+ */
+export interface ParsedAttrInfo {
+    key: string;
+    defaultValue: string;
+    bindable: boolean;
+    hasDefault: boolean;
+}
+/**
+ * Parsed origin schema from source
+ */
+export interface ParsedOriginSchema {
+    attrs: ParsedAttrInfo[];
+    parentNames: string[];
+}
+/**
+ * Parse an origin's schema from its source code.
+ *
+ * Looks for patterns like:
+ * ```ts
+ * export const Counter = $origin({
+ *   attrs: $attrs({
+ *     label: 'Counter',
+ *     count: $bindable(0),
+ *     step: 1 as number
+ *   }),
+ *   ...
+ * })
+ * ```
+ *
+ * @param source The source code of the origin file
+ * @param exportName The name of the exported origin (e.g., 'Counter')
+ * @returns Parsed schema or null if not found
+ */
+export declare function parseOriginSchemaFromSource(source: string, exportName: string): ParsedOriginSchema | null;
+/**
+ * Generate $props() destructuring code from parsed attrs
+ *
+ * Uses $attrs.Of<typeof Factory> type annotation which is properly connected
+ * to the factory type. This approach is required for svelte-check to properly
+ * infer component props from the origin factory definition.
+ *
+ * @example
+ * generatePropsDestructuring([
+ *   { key: 'label', defaultValue: "'Counter'", bindable: false, hasDefault: true },
+ *   { key: 'count', defaultValue: '0', bindable: true, hasDefault: true }
+ * ], 'Counter')
+ * // Returns: "let { label = 'Counter', count = $bindable(0) }: $attrs.Of<typeof Counter> = $props()"
+ */
+export declare function generatePropsDestructuring(attrs: ParsedAttrInfo[], factoryName: string): string;
+/**
+ * Generate factory call code from parsed attrs.
+ * For bindable attrs, we create getters AND setters to maintain two-way binding.
+ * For non-bindable attrs, we only create getters.
+ *
+ * @example
+ * generateFactoryCallFromAttrs('Counter', [
+ *   { key: 'label', defaultValue: "'Counter'", bindable: false, hasDefault: true },
+ *   { key: 'count', defaultValue: '0', bindable: true, hasDefault: true }
+ * ])
+ * // Returns: "Counter({ get label() { return label }, get count() { return count }, set count(v) { count = v } })"
+ */
+export declare function generateFactoryCallFromAttrs(factoryName: string, attrs: ParsedAttrInfo[]): string;
+/**
+ * Extract import path for a given identifier from source
+ *
+ * @example
+ * findImportPath("import { Counter } from './origins/counter.svelte'", 'Counter')
+ * // Returns: './origins/counter.svelte'
+ */
+export declare function findImportPath(source: string, identifier: string): string | null;
+/**
+ * Schema resolution context for async resolution
+ */
+export interface SchemaResolver {
+    /**
+     * Resolve the schema for an origin factory by its import path
+     * @param importPath The import path (e.g., './origins/counter.svelte')
+     * @param exportName The name of the exported origin (e.g., 'Counter')
+     * @returns Parsed schema or null if not resolvable
+     */
+    resolve(importPath: string, exportName: string): Promise<ParsedOriginSchema | null>;
+}
+/**
+ * Generate a TypeScript interface content from a parsed schema.
+ * Used for generating .svelte.d.ts declaration files.
+ *
+ * @param schema The parsed origin schema
+ * @returns Object with interfaceContent (the interface body) and bindings (array of bindable prop names)
+ */
+export declare function generatePropsInterface(schema: ParsedOriginSchema): {
+    interfaceContent: string;
+    bindings: string[];
+};
+/**
+ * Infer TypeScript type from a default value expression.
+ * Used for generating .d.ts files.
+ */
+export declare function inferTypeFromDefault(defaultValue: string): string;
+/**
+ * Generate the content for a .svelte.d.ts file.
+ * Shared between vite-dts.ts and generate-dts.ts.
+ *
+ * @param factoryName - The name of the origin factory
+ * @param importPath - The import path for the factory
+ * @param schema - The parsed origin schema
+ * @param comment - Optional custom comment for the file header
+ */
+export declare function generateDtsContent(factoryName: string, importPath: string, schema: ParsedOriginSchema, comment?: string): string;

package/dist/transform/standalone-attrs-transform.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Standalone $attrs() transformation logic.
+ *
+ * This module handles transforming standalone $attrs({...}) macro calls
+ * (outside of $origin definitions) into __createAttrs({...}) runtime calls.
+ */
+import type MagicString from 'magic-string';
+/**
+ * Transform standalone $attrs({...}) calls.
+ *
+ * Input:
+ * ```ts
+ * export const BaseAttrs = $attrs({
+ *   label: 'Default',
+ *   disabled: false
+ * })
+ *
+ * // With inheritance:
+ * export const WidgetAttrs = $attrs([BaseAttrs], {
+ *   value: $bindable(0)
+ * })
+ * ```
+ *
+ * Output:
+ * ```ts
+ * export const BaseAttrs = __createAttrs({
+ *   __attrSchema: { label: {...}, disabled: {...} }
+ * })
+ *
+ * export const WidgetAttrs = __createAttrs({
+ *   __parents: [BaseAttrs],
+ *   __attrSchema: { value: {...} }
+ * })
+ * ```
+ */
+export declare function transformStandaloneAttrsCalls(s: MagicString, source: string, neededImports: Set<string>): boolean;

package/dist/vite-dts.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Generate .svelte.d.ts declaration files for svelte-origin components
+ *
+ * This module generates sidecar .d.ts files when a component uses $attrs.origin().
+ * These declaration files help svelte-check and TypeScript understand the
+ * transformed props, since svelte2tsx runs on original file content.
+ */
+import type { Plugin } from 'vite';
+export interface DtsGeneratorOptions {
+    /** Enable debug logging */
+    debug?: boolean;
+}
+/**
+ * Create a Vite plugin that generates .svelte.d.ts files for origin-based components.
+ */
+export declare function svelteOriginDts(options?: DtsGeneratorOptions): Plugin;
+export default svelteOriginDts;