svelte-origin 0.0.0 → 1.0.0-next.15

package/dist/runtime/origin.d.ts

@@ -0,0 +1,144 @@
+/**
+ * Core origin factory for svelte-origin
+ *
+ * This module provides the runtime functions that macros expand to.
+ *
+ * Key design:
+ * - Origins are defined with $origin({...}) using `this` context and real runes
+ * - The macro transforms this into __createOrigin with __attrSchema and __create
+ * - Components use $attrs.origin(Counter) which expands to $props() + factory call
+ */
+import type { OriginFactory, AttrSchema, AttrsFactory, AttachmentFn } from './types';
+export { bindable, isBindable, extractAttrSchema, applyDefaults } from './attrs';
+export type * from './types';
+/**
+ * Create an origin factory.
+ *
+ * This is what the $origin({...}) macro compiles to.
+ *
+ * The transformation converts the user's object-with-this-context into:
+ * - __attrSchema: extracted attr metadata
+ * - __create: a function that receives reactive attrs and returns the instance
+ *
+ * @example
+ * // User writes:
+ * const Counter = $origin({
+ *   attrs: $attrs({ count: $bindable(0) }),
+ *   _internal: $state(0),
+ *   increment() { this.attrs.count++ }
+ * })
+ *
+ * // Transforms to:
+ * const Counter = __createOrigin({
+ *   __attrSchema: { count: { default: 0, bindable: true, hasDefault: true } },
+ *   __create: (attrs) => {
+ *     let _internal = $state(0)
+ *     return {
+ *       get attrs() { return attrs },
+ *       get _internal() { return _internal },
+ *       set _internal(v) { _internal = v },
+ *       increment() { attrs.count++ }
+ *     }
+ *   }
+ * })
+ */
+export declare function __createOrigin<TInstance, TAttrs extends Record<string, any>>(config: {
+    __attrSchema: AttrSchema;
+    __parents?: OriginFactory<any, any>[];
+    __create: (attrs: TAttrs, superInstances?: any[]) => TInstance;
+    __onInit?: (this: TInstance, ...args: any[]) => void | (() => void);
+    __attachments?: Record<string, AttachmentFn>;
+}): OriginFactory<TInstance, TAttrs>;
+/**
+ * Helper to get attrs for an origin factory from a raw attrs object.
+ * Used when $attrs.origin can't do full static analysis.
+ *
+ * Creates a writable wrapper around the readonly $props() object.
+ * This is necessary because Svelte 5's $props() returns a readonly proxy
+ * and the origin's internal __create function needs to write to props.
+ *
+ * The wrapper:
+ * - Reads from the original $props() object (maintaining reactivity)
+ * - Writes to a local cache, then syncs back to $props() if the prop is bindable
+ * - Falls back to local storage for non-bindable props (internal state)
+ *
+ * For inherited origins, this ensures parent attrs are recognized.
+ *
+ * @example
+ * // If preprocessor can't resolve the origin's schema statically:
+ * let __rawAttrs = $props()
+ * let counter = Counter(__attrsFor(Counter, __rawAttrs))
+ */
+export declare function __attrsFor<T extends {
+    __origin: true;
+}>(factory: T, rawAttrs: Record<string, any>): Record<string, any>;
+/**
+ * Get merged attr schema including all parent schemas.
+ * Parent schemas are merged first, then child's schema on top (child wins conflicts).
+ * Detects circular inheritance to prevent infinite loops.
+ */
+export declare function getMergedAttrSchema(factory: OriginFactory<any, any>, visited?: Set<OriginFactory<any, any>>): AttrSchema;
+/**
+ * Generate code for $props() destructuring from an attr schema.
+ * This is used by the transformer to generate the component's $props() call.
+ *
+ * @example
+ * generateAttrsDestructuring({
+ *   label: { default: 'Counter', bindable: false, hasDefault: true },
+ *   count: { default: 0, bindable: true, hasDefault: true }
+ * })
+ * // Returns: "{ label = 'Counter', count = $bindable(0) }"
+ */
+export declare function generateAttrsDestructuring(schema: AttrSchema): string;
+/**
+ * Generate code for the reactive attrs object with getters/setters.
+ * This links the destructured $props() variables to the attrs object.
+ *
+ * @example
+ * generateReactiveAttrsObject({
+ *   label: { default: 'Counter', bindable: false, hasDefault: true },
+ *   count: { default: 0, bindable: true, hasDefault: true }
+ * })
+ * // Returns: "{ get label() { return label }, get count() { return count }, set count(v) { count = v } }"
+ */
+export declare function generateReactiveAttrsObject(schema: AttrSchema): string;
+/**
+ * Create a standalone attrs factory.
+ *
+ * This is what standalone $attrs({...}) compiles to.
+ * Allows defining reusable attr schemas that can be imported and extended.
+ *
+ * @example
+ * // User writes:
+ * export const BaseAttrs = $attrs({
+ *   label: 'Default',
+ *   disabled: false
+ * })
+ *
+ * // Transforms to:
+ * export const BaseAttrs = __createAttrs({
+ *   __attrSchema: { label: {...}, disabled: {...} }
+ * })
+ *
+ * // Extended attrs:
+ * export const WidgetAttrs = $attrs([BaseAttrs], { value: $bindable(0) })
+ *
+ * // Transforms to:
+ * export const WidgetAttrs = __createAttrs({
+ *   __parents: [BaseAttrs],
+ *   __attrSchema: { value: {...} }
+ * })
+ */
+export declare function __createAttrs<TAttrs extends Record<string, any>>(config: {
+    __attrSchema: AttrSchema;
+    __parents?: AttrsFactory<any>[];
+}): AttrsFactory<TAttrs>;
+/**
+ * Check if a value is an AttrsFactory
+ */
+export declare function isAttrsFactory(value: unknown): value is AttrsFactory<any>;
+/**
+ * Get merged attr schema from an AttrsFactory including all parent schemas.
+ * Detects circular inheritance to prevent infinite loops.
+ */
+export declare function getMergedAttrSchemaFromAttrs(factory: AttrsFactory<any>, visited?: Set<AttrsFactory<any>>): AttrSchema;

package/dist/runtime/types.d.ts

@@ -0,0 +1,173 @@
+/**
+ * Core types for svelte-origin runtime
+ *
+ * This file defines the type system for origins.
+ *
+ * Key concepts:
+ * - Origins are defined with $origin({...}) macro using `this` context
+ * - The macro transforms to a factory with __attrSchema and __create
+ * - __create receives a reactive attrs object and returns an instance
+ */
+/**
+ * Marker type for bindable attrs.
+ * Used inside $origin({ attrs: $attrs({ count: $bindable(0) }) })
+ *
+ * At macro expansion time, $bindable is replaced with __bindable()
+ * to mark attrs that should become $bindable() in the component.
+ */
+export interface Bindable<T = unknown> {
+    readonly __bindable: true;
+    readonly default: T;
+}
+/**
+ * Schema describing a single attr's metadata.
+ * Extracted at transformation time from the attrs definition.
+ */
+export interface AttrSchemaEntry {
+    /** The default value (undefined if no default) */
+    default: unknown;
+    /** Whether this attr is bindable (two-way binding) */
+    bindable: boolean;
+    /** Whether this attr has a default value */
+    hasDefault: boolean;
+}
+/**
+ * Full attr schema for an origin.
+ * Maps attr name -> schema entry.
+ */
+export interface AttrSchema {
+    [key: string]: AttrSchemaEntry;
+}
+/**
+ * The reactive attrs object passed to the origin factory's __create function.
+ * This is created by the component with getters/setters that link to the
+ * actual $props() destructured variables.
+ *
+ * @example
+ * // In component after transformation:
+ * let { label = 'Counter', count = $bindable(0) } = $props()
+ * let __reactiveAttrs = {
+ *   get label() { return label },
+ *   get count() { return count },
+ *   set count(v) { count = v }
+ * }
+ * let counter = Counter.__create(__reactiveAttrs)
+ */
+export type ReactiveAttrs<T> = T extends Record<string, any> ? {
+    [K in keyof T]: UnwrapBindable<T[K]>;
+} : Record<string, never>;
+/**
+ * Unwrap Bindable<T> to T, pass through other types
+ */
+export type UnwrapBindable<T> = T extends Bindable<infer U> ? U : T;
+/**
+ * The factory object created by the $origin macro transformation.
+ *
+ * Contains:
+ * - __origin: marker for identification
+ * - __attrSchema: metadata about attrs (defaults, bindable markers)
+ * - __parents: parent origin factories for inheritance
+ * - __create: function that receives reactive attrs and returns instance
+ * - __onInit: optional callback that runs after instance creation, can receive extra args
+ *
+ * The factory is also callable for convenience: `Counter(attrs)` calls `Counter.__create(attrs)`
+ * Factory supports: `Counter(attrs?, ...initArgs?)` where initArgs are passed to __onInit
+ */
+export interface OriginFactory<TInstance = unknown, TAttrs = Record<string, any>> {
+    /** Create an instance with the given reactive attrs and optional init args */
+    (attrs?: TAttrs | null, ...initArgs: any[]): TInstance;
+    /** Marker to identify origin factories */
+    readonly __origin: true;
+    /** The attr schema extracted from the definition */
+    readonly __attrSchema: AttrSchema;
+    /** Parent origin factories (for inheritance) */
+    readonly __parents: OriginFactory<any, any>[];
+    /** The actual factory function that creates instances */
+    readonly __create: (attrs: TAttrs, superInstances?: any[]) => TInstance;
+    /** Optional initialization callback that runs after instance creation, receives any extra args passed to factory */
+    readonly __onInit?: (this: TInstance, ...args: any[]) => void | (() => void);
+}
+/**
+ * Standalone attrs schema factory created by $attrs({...}) outside of $origin.
+ * Can be used to define reusable attr schemas.
+ *
+ * @example
+ * // Define reusable attrs
+ * export const BaseAttrs = $attrs({
+ *   label: 'Default',
+ *   disabled: false
+ * })
+ *
+ * // Extend in origin
+ * export const Widget = $origin({
+ *   props: $attrs([BaseAttrs], {
+ *     value: $bindable(0)
+ *   })
+ * })
+ */
+export interface AttrsFactory<_TAttrs = Record<string, any>> {
+    /** Marker to identify attrs factories */
+    readonly __attrs: true;
+    /** The attr schema */
+    readonly __attrSchema: AttrSchema;
+    /** Parent attr factories (for inheritance) */
+    readonly __parents: AttrsFactory<any>[];
+}
+/**
+ * The origin instance has:
+ * - attrs: reactive attrs object (passed in)
+ * - super: parent instance (if extending)
+ * - All other members from the definition (state, getters, methods)
+ */
+export interface OriginInstance<TAttrs = Record<string, any>> {
+    /** Reactive attrs object */
+    readonly attrs: TAttrs;
+    /** Parent instance (if extending) */
+    readonly super?: any;
+    /** Additional members from definition */
+    [key: string]: any;
+}
+/**
+ * Extract the component attrs type from an origin's attr schema.
+ * This is what the component will accept as attrs.
+ */
+export type ComponentAttrs<T extends OriginFactory<any, any>> = T extends OriginFactory<any, infer A> ? Partial<A> : Record<string, any>;
+/**
+ * Extract the instance type from an origin factory
+ */
+export type InstanceOf<T extends OriginFactory<any, any>> = T extends OriginFactory<infer I, any> ? I : never;
+/**
+ * Merge parent origins with child definition.
+ * The child's attrs are merged with parent attrs.
+ * The child gets access to `this.super` for parent methods.
+ */
+export type MergedOrigin<Parents extends OriginFactory<any, any>[], TInstance> = TInstance & {
+    super: Parents extends [OriginFactory<infer P, any>] ? P : Parents extends [OriginFactory<infer P1, any>, ...infer _Rest] ? P1 : never;
+};
+/**
+ * Attrs for a child origin (used with $attrs.for).
+ * Extracts the attrs type from the origin's schema.
+ */
+export type AttrsFor<T extends OriginFactory<any, any>> = T extends OriginFactory<any, infer A> ? A : Record<string, any>;
+/**
+ * Attr mapping for $attrs.for with custom mappings
+ */
+export type AttrMapping<TSource = any, TTarget = any> = {
+    [K in keyof TTarget]?: (source: TSource) => TTarget[K];
+};
+/**
+ * Valid HTML element names for $attrs.for('element').
+ * At compile time, this maps to svelte/elements types.
+ */
+export type HTMLElementName = keyof HTMLElementTagNameMap | string;
+/**
+ * Placeholder type for element attrs.
+ * The real type resolution happens at compile time using svelte/elements.
+ */
+export type ElementAttrs<_K extends HTMLElementName> = Record<string, any>;
+/**
+ * An attachment function that runs when an element is attached.
+ * Can return a cleanup function that runs when the element is detached
+ * or when the attachment re-runs.
+ */
+export type AttachmentFn = (this: any, element: Element) => void | (() => void);

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

@@ -0,0 +1,24 @@
+/**
+ * $attrs.for() transformation logic.
+ *
+ * This module handles transforming $attrs.for(X) calls which support:
+ * - $attrs.for(OriginFactory) - get attrs for an origin factory
+ * - $attrs.for('input') - get typed element attrs
+ */
+import type MagicString from 'magic-string';
+/**
+ * Transform $attrs.for(X) calls.
+ * Handles both origin factories ($attrs.for(OriginFactory)) and element names ($attrs.for('input'))
+ *
+ * If $props() already exists, we extend the existing destructuring with rest syntax.
+ * Otherwise, we generate a new $props() call.
+ *
+ * Supports all TypeScript declaration patterns:
+ * - let x = $attrs.for(Factory)
+ * - const x = $attrs.for(Factory)
+ * - let x: Type = $attrs.for(Factory)
+ * - const x: Type<T> = $attrs.for(Factory)
+ * - export let x = $attrs.for(Factory)
+ * - export const x: Type = $attrs.for('input')
+ */
+export declare function transformAttrsForCalls(s: MagicString, source: string, neededImports: Set<string>): boolean;

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

@@ -0,0 +1,62 @@
+/**
+ * $attrs.origin() transformation logic.
+ *
+ * This module handles transforming $attrs.origin(Factory) calls in component scripts
+ * into proper $props() destructuring and factory calls.
+ */
+import type MagicString from 'magic-string';
+import { type SchemaResolver } from './schema';
+/**
+ * Result from transformAttrsOriginCalls including $$Props info for later injection
+ */
+export interface AttrsOriginTransformResult {
+    changed: boolean;
+    propsTypeDeclaration: string | null;
+}
+/**
+ * Transform $attrs.origin(X) calls in component scripts (sync fallback version).
+ *
+ * This version always uses the fallback approach since no schema resolver is provided.
+ * Returns info about $$Props that needs to be injected (but doesn't inject it).
+ *
+ * Supports all TypeScript declaration patterns:
+ * - let x = $attrs.origin(Factory)
+ * - const x = $attrs.origin(Factory)
+ * - let x: Type = $attrs.origin(Factory)
+ * - const x: Type<T> = $attrs.origin(Factory)
+ * - export let x = $attrs.origin(Factory)
+ * - export const x: Type = $attrs.origin(Factory)
+ * - Generic factory call: $attrs.origin(List<T>())
+ */
+export declare function transformAttrsOriginCallsSync(s: MagicString, source: string, neededImports: Set<string>): AttrsOriginTransformResult;
+/**
+ * Transform $attrs.origin(X) calls in component scripts.
+ *
+ * When schema is available (via static resolution):
+ * ```svelte
+ * let counter = $attrs.origin(Counter)
+ * ```
+ * Becomes:
+ * ```svelte
+ * let { label = 'Counter', count = $bindable(0), step = 1 } = $props()
+ * let counter = Counter({ label, count, step })
+ * ```
+ *
+ * Fallback (when schema isn't statically known):
+ * ```svelte
+ * let ___attrs: $$Props = $props()
+ * let counter = Counter(__attrsFor(Counter, ___attrs))
+ * ```
+ *
+ * Returns info about $$Props that needs to be injected (but doesn't inject it).
+ *
+ * Supports all TypeScript declaration patterns:
+ * - let x = $attrs.origin(Factory)
+ * - const x = $attrs.origin(Factory)
+ * - let x: Type = $attrs.origin(Factory)
+ * - const x: Type<T> = $attrs.origin(Factory)
+ * - export let x = $attrs.origin(Factory)
+ * - export const x: Type = $attrs.origin(Factory)
+ * - Generic factory call: $attrs.origin(List<T>())
+ */
+export declare function transformAttrsOriginCalls(s: MagicString, source: string, neededImports: Set<string>, schemaResolver?: SchemaResolver): Promise<AttrsOriginTransformResult>;

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

@@ -0,0 +1,52 @@
+/**
+ * Attribute schema parsing and generation utilities.
+ *
+ * This module handles parsing $attrs({...}) content and generating
+ * the __attrSchema object that describes each attribute's metadata.
+ */
+/**
+ * Parsed attribute details for code generation
+ */
+export interface AttrDetail {
+    key: string;
+    defaultValue: string;
+    bindable: boolean;
+    hasDefault: boolean;
+}
+/**
+ * Generate __attrSchema code from the attrs source.
+ *
+ * Input: 'label: "Counter", count: $bindable(0), step: undefined as undefined | number'
+ * Output: '{ label: { default: "Counter", bindable: false, hasDefault: true }, ... }'
+ */
+export declare function generateAttrSchemaFromSource(attrsSource: string): string;
+/**
+ * Parse attrs source and return structured details for each attr.
+ *
+ * Input: 'label: "Counter", count: $bindable(0), step: 1 as number'
+ * Output: [{ key: 'label', defaultValue: '"Counter"', bindable: false, hasDefault: true }, ...]
+ */
+export declare function parseAttrsSource(attrsSource: string): AttrDetail[];
+/**
+ * Split attrs source by top-level commas.
+ * Handles strings and comments correctly.
+ */
+export declare function splitAttrsSource(source: string): string[];
+/**
+ * Parse members from an object literal source.
+ * This is a simplified parser - a proper implementation would use AST.
+ */
+export interface ObjectMember {
+    key: string;
+    value: string;
+    isGetter: boolean;
+    isSetter: boolean;
+    isMethod: boolean;
+    isAsync: boolean;
+    isGenerator: boolean;
+    isComputed: boolean;
+}
+/**
+ * Parse members from an object literal source.
+ */
+export declare function parseObjectMembers(source: string): ObjectMember[];

package/dist/transform/codegen.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Code generation utilities for svelte-origin transformations
+ */
+/**
+ * Generate the import statement for runtime functions.
+ *
+ * @example
+ * generateRuntimeImport(['__createOrigin', '__attrsFor'])
+ * // Returns: "import { __createOrigin, __attrsFor } from 'svelte-origin/runtime'"
+ */
+export declare function generateRuntimeImport(functions: string[]): string;
+/**
+ * Indent each line of code by a given amount
+ */
+export declare function indent(code: string, tabs?: number): string;

package/dist/transform/core.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Core transformation logic for svelte-origin
+ *
+ * This module is the main entry point for transformations that convert
+ * macro syntax into runtime calls.
+ *
+ * Key transformations:
+ * 1. $origin({...}) in .svelte.ts files -> __createOrigin({...})
+ * 2. $attrs.origin(Counter) in .svelte files -> $props() + factory call
+ * 3. $attrs.for(Child) -> attr forwarding for origin factories
+ * 4. $attrs.for('input') -> typed element attrs
+ *
+ * The actual transformation logic is split into focused modules:
+ * - declaration-parser.ts: TypeScript declaration parsing utilities
+ * - attrs-schema.ts: $attrs schema generation and parsing
+ * - origin-transform.ts: $origin() transformation
+ * - standalone-attrs-transform.ts: standalone $attrs() transformation
+ * - attrs-origin-transform.ts: $attrs.origin() transformation
+ * - attrs-for-transform.ts: $attrs.for() transformation
+ */
+import MagicString from 'magic-string';
+import type { SchemaResolver } from './schema';
+export type { SchemaResolver } from './schema';
+export type { AttrDetail } from './attrs-schema';
+export type { AttrsOriginTransformResult } from './attrs-origin-transform';
+export interface TransformOptions {
+    /** The filename being transformed */
+    filename?: string;
+    /** Whether this is a component script (vs a module) */
+    isComponent?: boolean;
+    /** Schema resolver for static analysis of $attrs.origin() calls */
+    schemaResolver?: SchemaResolver;
+}
+export interface TransformResult {
+    /** The transformed code */
+    code: string;
+    /** Whether any transformations were made */
+    changed: boolean;
+    /** Source map (if changes were made) */
+    map?: ReturnType<MagicString['generateMap']>;
+}
+/**
+ * Transform a script/module containing svelte-origin macros.
+ * Main entry point for transformations.
+ *
+ * @overload Sync version when no schemaResolver is provided
+ * @overload Async version when schemaResolver is provided
+ */
+export declare function transformScript(source: string, options?: TransformOptions & {
+    schemaResolver?: undefined;
+}): TransformResult;
+export declare function transformScript(source: string, options: TransformOptions & {
+    schemaResolver: SchemaResolver;
+}): Promise<TransformResult>;
+/**
+ * Transform script content from the script hook.
+ *
+ * This is similar to transformScriptAsync but designed for the script hook
+ * where the content is already extracted (no <script> tags).
+ * Imports are always prepended at the start of the content.
+ */
+export declare function transformScriptContent(source: string, options: TransformOptions): Promise<TransformResult>;

package/dist/transform/declaration-parser.d.ts

@@ -0,0 +1,77 @@
+/**
+ * TypeScript/JavaScript declaration parsing utilities.
+ *
+ * This module handles parsing variable declarations from source code,
+ * with full support for TypeScript type annotations, generics, and exports.
+ */
+/**
+ * Information about a variable declaration found in source code.
+ * Handles all TypeScript declaration variants:
+ *
+ * Basic:
+ *   let x = value
+ *   const x = value
+ *
+ * With type annotation:
+ *   let x: Type = value
+ *   const x: Type<T> = value
+ *   const x: Type<T, U<V>> = value
+ *
+ * With export:
+ *   export let x = value
+ *   export const x: Type = value
+ *
+ * Complex types:
+ *   let x: Type | Other = value
+ *   let x: Type & Other = value
+ *   let x: () => Type = value
+ */
+export interface VariableDeclaration {
+    /** The variable name */
+    varName: string;
+    /** Start index of the entire declaration (including export/let/const) */
+    startIndex: number;
+    /** Index where the value expression starts (after =) */
+    valueStartIndex: number;
+    /** Whether it has 'export' keyword */
+    hasExport: boolean;
+    /** The type annotation if present (without the colon) */
+    typeAnnotation: string | null;
+}
+/**
+ * Find all variable declarations that are assigned a specific macro call.
+ * Handles all TypeScript declaration patterns:
+ *
+ * - let x = $macro(...)
+ * - const x = $macro(...)
+ * - let x: Type = $macro(...)
+ * - const x: Type<T> = $macro(...)
+ * - export let x = $macro(...)
+ * - export const x: Type = $macro(...)
+ *
+ * @param source The source code to search
+ * @param macroPattern The macro to find (e.g., '$attrs.origin', '$attrs.for', '$origin')
+ * @returns Array of declarations with their metadata
+ */
+export declare function findVariableDeclarationsWithMacro(source: string, macroPattern: string): (VariableDeclaration & {
+    macroOpenParen: number;
+})[];
+/**
+ * Look backwards from a position to find a variable declaration.
+ * Handles: [export] (let|const) varName [: Type] =
+ */
+export declare function findDeclarationBefore(source: string, beforeIndex: number): VariableDeclaration | null;
+/**
+ * Check if the source already has a $$Props type declaration.
+ * Looks for 'type $$Props' or 'interface $$Props' patterns.
+ */
+export declare function hasExistingPropsDeclaration(source: string): boolean;
+/**
+ * Find the position right after imports to inject $$Props.
+ * Returns the position after the last import statement, or after the script tag.
+ *
+ * Handles both single-line and multi-line imports:
+ * - import { x } from 'y'
+ * - import {\n  x,\n  y\n} from 'z'
+ */
+export declare function findPropsInjectionPosition(source: string): number;

package/dist/transform/element-types.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Get the svelte/elements type import for an HTML element name.
+ *
+ * Uses svelteHTML.IntrinsicElements for type-checking compatibility with Svelte's
+ * internal createElement function, which expects IntrinsicElements types.
+ *
+ * @param element - The HTML element name (e.g., 'input', 'button', 'div')
+ * @returns The full type expression using svelteHTML.IntrinsicElements
+ */
+export declare function getElementTypeImport(element: string): string;

package/dist/transform/origin-transform.d.ts

@@ -0,0 +1,51 @@
+/**
+ * $origin() transformation logic.
+ *
+ * This module handles transforming $origin({...}) macro calls into
+ * __createOrigin({...}) runtime calls with proper code generation.
+ */
+import type MagicString from 'magic-string';
+/**
+ * Result of transforming the origin body
+ */
+export interface TransformOriginBodyResult {
+    body: string;
+    attachments: string[];
+}
+/**
+ * Transform $origin({...}) macro calls.
+ *
+ * Input:
+ * ```ts
+ * export const Counter = $origin({
+ *   attrs: $attrs({
+ *     label: 'Counter',
+ *     count: $bindable(0)
+ *   }),
+ *   _internal: $state(0),
+ *   get double() { return $derived(this.attrs.count * 2) },
+ *   increment() { this.attrs.count++ }
+ * })
+ * ```
+ *
+ * Output:
+ * ```ts
+ * export const Counter = __createOrigin({
+ *   __attrSchema: {
+ *     label: { default: "Counter", bindable: false, hasDefault: true },
+ *     count: { default: 0, bindable: true, hasDefault: true }
+ *   },
+ *   __create: (attrs) => {
+ *     let _internal = $state(0)
+ *     return {
+ *       get attrs() { return attrs },
+ *       get _internal() { return _internal },
+ *       set _internal(v) { _internal = v },
+ *       get double() { return $derived(attrs.count * 2) },
+ *       increment() { attrs.count++ }
+ *     }
+ *   }
+ * })
+ * ```
+ */
+export declare function transformOriginCalls(s: MagicString, source: string, neededImports: Set<string>): boolean;