svelte-origin 0.0.0 → 1.0.0-next.49

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

@@ -0,0 +1,143 @@
+/**
+ * Helper functions for transforming $origin({...}) body content.
+ *
+ * These are extracted from the main transformOriginBody to improve
+ * testability and maintainability. Each function has a clear,
+ * focused responsibility.
+ */
+import type { AttrDetail, ObjectMember } from './attrs-schema';
+/**
+ * Parsed $origin.create() call information.
+ */
+export interface ParsedOriginCreateCall {
+    callStart: number;
+    callEnd: number;
+    factoryExpr: string;
+    propsExpr: string | null;
+}
+/**
+ * Find and parse all $origin.create() calls in code.
+ * Returns positions and parsed arguments for each call.
+ *
+ * Used by both string-based transformation (inside origin definitions)
+ * and MagicString-based transformation (top-level source code).
+ */
+export declare function findOriginCreateCalls(code: string): ParsedOriginCreateCall[];
+/**
+ * Transform $origin.bind(expr) markers into __bindable() calls.
+ *
+ * - `$origin.bind(myVar)` → `__bindable(() => myVar, (v) => { myVar = v })`
+ * - `$origin.bind(obj.prop)` → `__bindable(() => obj.prop, (v) => { obj.prop = v })`
+ *
+ * Returns transformed code and whether any bind markers were found.
+ */
+export declare function transformOriginBindMarkers(propsExpr: string): {
+    code: string;
+    hasBindable: boolean;
+};
+/**
+ * Generate replacement code for an $origin.create() call.
+ *
+ * - `$origin.create(Factory)` → `Factory({})`
+ * - `$origin.create(Factory, props)` → `__createOriginInstance(Factory, transformedProps)`
+ *
+ * Also transforms $origin.bind() markers inside props to __bindable() calls.
+ */
+export declare function generateOriginCreateReplacement(factoryExpr: string, propsExpr: string | null): {
+    replacement: string;
+    needsHelper: boolean;
+    needsBindable: boolean;
+};
+/**
+ * Transform inline $origin.create() calls within a code string.
+ * Used for transforming content inside $origin({...}) definitions.
+ *
+ * Returns the transformed code, whether __createOriginInstance is needed,
+ * and whether __bindable is needed for $origin.bind() markers.
+ */
+export declare function transformInlineOriginCreate(code: string): {
+    result: string;
+    needsHelper: boolean;
+    needsBindable: boolean;
+};
+/**
+ * Metadata collected from first-pass analysis of origin members
+ */
+export interface MemberMetadata {
+    /** Getters containing $derived - will be hoisted to __name variables */
+    derivedNames: Set<string>;
+    /** $state(...) properties - will be hoisted to local variables */
+    stateNames: Set<string>;
+    /** Regular value properties (non-$state, non-getter, non-method) */
+    valueNames: Set<string>;
+    /** Methods - need to keep this.method() for these */
+    methodNames: Set<string>;
+    /** All getters (including non-$derived) */
+    getterNames: Set<string>;
+    /** Getters that only return this.super.X */
+    superDelegatingGetters: Set<string>;
+    /** Methods that only return this.super.X() */
+    superDelegatingMethods: Set<string>;
+}
+/**
+ * Context for code transformation
+ */
+export interface TransformContext {
+    /** Whether the origin has parent(s) for inheritance */
+    hasParents: boolean;
+    /** The property name used for attrs (e.g., 'props', 'attrs') */
+    propName: string;
+    /** Member metadata collected from first pass */
+    metadata: MemberMetadata;
+}
+/**
+ * Analyze object members and collect metadata about their types.
+ * This first pass determines which members need hoisting, transformation, etc.
+ */
+export declare function collectMemberMetadata(members: ObjectMember[], hasParents: boolean): MemberMetadata;
+/**
+ * Transform code that runs BEFORE object creation (hoisted code).
+ * e.g., $derived expressions, $state initializers
+ *
+ * CRITICAL: In hoisted code, `this` does NOT exist. All member access must be:
+ * - Local variables (__props, __name, name) for locally defined members
+ * - __super.member for inherited members from parents
+ */
+export declare function transformForHoistedCode(code: string, ctx: TransformContext): string;
+/**
+ * Transform code that runs AFTER object creation (methods, getters).
+ *
+ * CRITICAL: We use `__self` instead of `this` because Svelte's reactivity
+ * may call getters/methods without proper `this` binding.
+ */
+export declare function transformForMemberCode(code: string, ctx: TransformContext): string;
+/**
+ * Generate the __props wrapper code that provides defaults for attrs.
+ *
+ * The setter checks if __inputAttrs has a setter before writing.
+ * This ensures getter-only props (from $origin.create without $origin.bind)
+ * cannot be modified by the origin - enforcing one-directional data flow.
+ */
+export declare function generatePropsWrapper(attrDetails: AttrDetail[]): string;
+/**
+ * Process a $state field and generate its declaration.
+ * Returns null if not a valid $state field.
+ */
+export declare function processStateField(key: string, value: string): {
+    declaration: string;
+    getter: string;
+    setter: string;
+} | null;
+/**
+ * Process a getter with $derived and generate its declaration.
+ * Returns null if not a $derived getter.
+ */
+export declare function processDerivedGetter(key: string, value: string, ctx: TransformContext): {
+    declaration: string;
+    getter: string;
+} | null;
+/**
+ * Normalize indentation of a code block to a target base level.
+ * Removes existing indentation and applies new consistent indentation.
+ */
+export declare function normalizeIndentation(code: string, targetIndent: string): string;

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

@@ -0,0 +1,32 @@
+/**
+ * $origin.create() transformation logic.
+ *
+ * This module handles transforming $origin.create(Factory, props?) calls
+ * into proper reactive origin instantiation.
+ *
+ * Unlike $origin.component() which binds to $props(), $origin.create() is used
+ * outside of component context and wraps props in $state() for reactivity.
+ */
+import type MagicString from 'magic-string';
+/**
+ * Transform $origin.create() calls in source code.
+ *
+ * This creates reactive origin instances outside of component context.
+ * Props are wrapped in $state() to maintain reactivity.
+ */
+export declare function transformOriginCreateCalls(s: MagicString, source: string, neededImports: Set<string>): boolean;
+/**
+ * Transform inline $origin.create() calls that are NOT variable declarations.
+ *
+ * These are calls like:
+ * - `childCounter: $origin.create(SimpleCounter)`
+ * - `this.childCounter = $origin.create(SimpleCounter)`
+ *
+ * Since we can't expand to multiple lines in these contexts, we transform:
+ * - `$origin.create(Factory)` → `Factory({})`
+ * - `$origin.create(Factory, { ... })` → `__createOriginInstance(Factory, { ... })`
+ * - `$origin.bind(expr)` inside props → `__bindable(() => expr, (v) => { expr = v })`
+ *
+ * Uses shared parsing logic from origin-body-helpers.ts.
+ */
+export declare function transformInlineOriginCreateCalls(s: MagicString, source: string, neededImports: Set<string>): boolean;

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

@@ -0,0 +1,62 @@
+/**
+ * Origin destructuring transformation logic.
+ *
+ * Handles patterns like:
+ * - `let { increment } = counter` - destructure methods with this-binding
+ * - `let { value } = counter.props` - destructure props directly
+ * - `let { props: { value } } = counter` - nested props destructuring
+ * - `let { value = $bindable(0) } = counter.props` - override with bindable
+ *
+ * Methods are bound to preserve `this` context.
+ * Props are converted to reactive $derived values.
+ */
+import type MagicString from 'magic-string';
+import type { TrackedOriginInstance } from './attrs-origin-transform';
+/**
+ * Parsed destructuring pattern from origin
+ */
+export interface OriginDestructure {
+    /** Full match start position */
+    startPos: number;
+    /** Full match end position */
+    endPos: number;
+    /** The source variable being destructured from */
+    sourceVar: string;
+    /** Whether destructuring from .props (e.g., counter.props) */
+    isPropsAccess: boolean;
+    /** Destructured method names (need this binding) */
+    methods: DestructuredItem[];
+    /** Destructured props (need reactive access) */
+    props: DestructuredProp[];
+    /** Props pattern within nested `props: { ... }` */
+    nestedPropsPattern: NestedPropsPattern | null;
+}
+export interface DestructuredItem {
+    /** Original key in the origin */
+    key: string;
+    /** Alias if renamed (e.g., `increment: inc`) */
+    alias: string | null;
+    /** Default value if provided */
+    defaultValue: string | null;
+}
+export interface DestructuredProp extends DestructuredItem {
+    /** Whether $bindable() was used in the default */
+    isBindable: boolean;
+    /** The value inside $bindable() if bindable */
+    bindableDefault: string | null;
+}
+export interface NestedPropsPattern {
+    /** Start of the `props: { ... }` pattern */
+    startPos: number;
+    /** End of the `props: { ... }` pattern */
+    endPos: number;
+    /** Props within the nested pattern */
+    props: DestructuredProp[];
+}
+/**
+ * Transform origin destructuring patterns in the source.
+ *
+ * Tracks origin instances created via $origin.component() or direct factory calls,
+ * then transforms destructuring patterns that reference them.
+ */
+export declare function transformOriginDestructuring(s: MagicString, source: string, originInstances: Map<string, TrackedOriginInstance>): boolean;

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({
+ *   props: $origin.props({
+ *     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>, svelteImports?: Set<string>): boolean;

package/dist/transform/patterns.d.ts

@@ -0,0 +1,86 @@
+/**
+ * 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 $origin.props({...}) inside origin definition */
+    originPropsInOrigin: RegExp;
+    /** Match standalone $origin.props({...}) or $origin.props([...], {...}) */
+    standaloneOriginProps: RegExp;
+    /** Match $bindable(...) inside attrs */
+    bindableInAttrs: RegExp;
+    /** Match $origin.component(X) */
+    originComponent: RegExp;
+    /** Match $origin.create(X) or $origin.create(X, {...}) */
+    originCreate: RegExp;
+    /** Match $origin.bind(X) inside $origin.create props */
+    originBind: RegExp;
+    /** Match $origin.for(X) where X is an identifier (origin factory) */
+    originForOrigin: RegExp;
+    /** Match $origin.for('x') where x is a string (element name) */
+    originForElement: 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 $origin.component(X) calls in source
+ */
+export declare function findOriginComponentCalls(source: string): {
+    name: string;
+    index: number;
+    length: number;
+}[];
+/**
+ * Find all $origin.for(X) calls in source where X is an origin factory
+ */
+export declare function findOriginForCalls(source: string): {
+    name: string;
+    index: number;
+    length: number;
+}[];
+/**
+ * Find all $origin.for('x') calls in source where x is an element name
+ */
+export declare function findOriginForElementCalls(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/reserved-keywords.d.ts

@@ -0,0 +1,87 @@
+/**
+ * Reserved keyword handling for generated code.
+ *
+ * JavaScript/TypeScript reserved keywords cannot be used as bare identifiers
+ * in destructuring patterns. When a prop name is a reserved keyword (like 'class'),
+ * we need to use a renamed internal variable.
+ *
+ * Example:
+ * ```ts
+ * // This is INVALID:
+ * let { class = '' } = $props()
+ *
+ * // This is VALID:
+ * let { class: ___class = '' } = $props()
+ * ```
+ */
+/**
+ * Check if a string is a reserved keyword that needs renaming
+ */
+export declare function isReservedKeyword(name: string): boolean;
+/**
+ * Get the internal variable name for a prop.
+ *
+ * For reserved keywords and collision prevention, we prefix with `___`.
+ * This ensures the generated code is valid JavaScript.
+ *
+ * @param propName The original prop name
+ * @param forcePrefix If true, always add prefix (for collision prevention)
+ * @returns The internal variable name to use
+ *
+ * @example
+ * getInternalVarName('class') // '___class'
+ * getInternalVarName('value') // '___value'
+ * getInternalVarName('count') // '___count'
+ */
+export declare function getInternalVarName(propName: string): string;
+/**
+ * Generate the prop destructuring part for a single prop.
+ * Handles reserved keywords by using property renaming.
+ *
+ * @param propName The original prop name
+ * @param defaultValue The default value expression (already formatted)
+ * @returns The destructuring part for this prop
+ *
+ * @example
+ * // Reserved keyword
+ * generatePropDestructure('class', "''")
+ * // Returns: "class: ___class = ''"
+ *
+ * // Normal prop
+ * generatePropDestructure('value', '$bindable()')
+ * // Returns: "value: ___value = $bindable()"
+ */
+export declare function generatePropDestructure(propName: string, defaultValue: string): string;
+/**
+ * Generate the prop destructuring part for a prop without a default value.
+ *
+ * @param propName The original prop name
+ * @returns The destructuring part for this prop
+ *
+ * @example
+ * generatePropDestructureNoDefault('class')
+ * // Returns: "class: ___class"
+ */
+export declare function generatePropDestructureNoDefault(propName: string): string;
+/**
+ * Generate a getter for the reactive attrs wrapper.
+ *
+ * @param propName The original prop name
+ * @returns The getter definition
+ *
+ * @example
+ * generateGetter('class')
+ * // Returns: "get class() { return ___class }"
+ */
+export declare function generateGetter(propName: string): string;
+/**
+ * Generate a setter for the reactive attrs wrapper.
+ *
+ * @param propName The original prop name
+ * @returns The setter definition
+ *
+ * @example
+ * generateSetter('class')
+ * // Returns: "set class(v) { ___class = v }"
+ */
+export declare function generateSetter(propName: string): string;

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

@@ -0,0 +1,105 @@
+/**
+ * Schema code generation utilities for svelte-origin
+ *
+ * This module handles generating code from parsed schemas:
+ * - $props() destructuring
+ * - Factory call generation
+ * - TypeScript type inference
+ * - .d.ts file generation
+ */
+import type { ParsedAttrInfo, ParsedOriginSchema } from './schema-types';
+/**
+ * Options for generating props destructuring.
+ */
+export interface GeneratePropsDestructuringOptions {
+    /**
+     * If true, use `$origin.Props` type helper (new API).
+     * If false, use `$origin.Props` type helper (legacy API).
+     * Defaults to true (new API).
+     */
+    useNewApi?: boolean;
+    /**
+     * If true, uses `$$Props` as the type annotation instead of generating one.
+     * This is used when the user has already declared their own `$$Props` type.
+     */
+    useUserPropsType?: boolean;
+}
+/**
+ * Generate $props() destructuring code from parsed attrs
+ *
+ * Uses `$origin.Props<typeof Factory>` type annotation (new API) or
+ * `$origin.Props<typeof Factory>` (legacy API) 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.
+ *
+ * For generic factory functions that are called (e.g., `TableState<T>()`),
+ * uses `$origin.Props<ReturnType<typeof TableState<T>>>` since `typeof` cannot
+ * be applied to a function call expression.
+ *
+ * All props use internal variable names (prefixed with ___) to:
+ * 1. Avoid reserved keyword conflicts (e.g., 'class' -> 'class: ___class')
+ * 2. Prevent accidental naming collisions with user code
+ *
+ * @example
+ * // Direct origin export (new API - default)
+ * generatePropsDestructuring([
+ *   { key: 'class', defaultValue: "''", bindable: false, hasDefault: true },
+ *   { key: 'count', defaultValue: '0', bindable: true, hasDefault: true }
+ * ], 'Counter')
+ * // Returns: "let { class: ___class = '', count: ___count = $bindable(0) }: $origin.Props<typeof Counter> = $props()"
+ *
+ * @example
+ * // Generic factory function
+ * generatePropsDestructuring([
+ *   { key: 'data', defaultValue: '[] as T[]', bindable: true, hasDefault: true }
+ * ], 'TableState<User>()')
+ * // Returns: "let { data: ___data = $bindable([] as T[]) }: $origin.Props<ReturnType<typeof TableState<User>>> = $props()"
+ *
+ * @example
+ * // Legacy API
+ * generatePropsDestructuring([...], 'Counter', { useNewApi: false })
+ * // Returns: "let { ... }: $origin.Props<typeof Counter> = $props()"
+ */
+export declare function generatePropsDestructuring(attrs: ParsedAttrInfo[], factoryName: string, options?: GeneratePropsDestructuringOptions): 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.
+ *
+ * Getters/setters reference internal variable names (___key) that were
+ * destructured from $props().
+ *
+ * @example
+ * generateFactoryCallFromAttrs('Counter', [
+ *   { key: 'class', defaultValue: "''", bindable: false, hasDefault: true },
+ *   { key: 'count', defaultValue: '0', bindable: true, hasDefault: true }
+ * ])
+ * // Returns: "Counter({ get class() { return ___class }, get count() { return ___count }, set count(v) { ___count = v } })"
+ */
+export declare function generateFactoryCallFromAttrs(factoryName: string, attrs: ParsedAttrInfo[]): string;
+/**
+ * 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/schema-parse.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Schema parsing 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.
+ */
+import type { ParsedOriginSchema } from './schema-types';
+/**
+ * Parse an origin's schema from its source code.
+ *
+ * Looks for patterns like:
+ * ```ts
+ * export const Counter = $origin({
+ *   props: $origin.props({
+ *     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;
+/**
+ * Parse an $origin.props factory's schema from its source code.
+ *
+ * Looks for patterns like:
+ * ```ts
+ * export const TextAttrs = $origin.props({ ... })
+ * export const TextAttrs = $origin.props([BaseAttrs], { ... })
+ * ```
+ *
+ * Or compiled:
+ * ```js
+ * export var TextAttrs = __createAttrs({ __attrSchema: {...}, __parents: [...] })
+ * ```
+ */
+export declare function parseAttrsSchemaFromSource(source: string, exportName: string): ParsedOriginSchema | null;
+/**
+ * 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;

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

@@ -0,0 +1,40 @@
+/**
+ * Schema types for svelte-origin
+ *
+ * Contains shared type definitions used across schema parsing and code generation.
+ */
+/**
+ * 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[];
+    /** Reference to external $origin.props factory (e.g., 'TextAttrs' when props: TextAttrs is used) */
+    propsRef?: string;
+}
+/**
+ * Schema resolution context for async resolution
+ */
+export interface SchemaResolver {
+    /**
+     * Resolve the schema for an origin factory by its import path.
+     *
+     * When importPath is null (e.g., import is in module script, not visible
+     * to component script), implementations may use alternative resolution
+     * strategies such as searching common sibling file patterns.
+     *
+     * @param importPath The import path (e.g., './origins/counter.svelte') or null if not found
+     * @param exportName The name of the exported origin (e.g., 'Counter')
+     * @returns Parsed schema or null if not resolvable
+     */
+    resolve(importPath: string | null, exportName: string): Promise<ParsedOriginSchema | null>;
+}

package/dist/transform/schema.d.ts

@@ -0,0 +1,11 @@
+/**
+ * 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.
+ *
+ * This is a barrel file that re-exports from the split modules for backwards compatibility.
+ */
+export type { ParsedAttrInfo, ParsedOriginSchema, SchemaResolver } from './schema-types';
+export { parseOriginSchemaFromSource, parseAttrsSchemaFromSource, findImportPath } from './schema-parse';
+export { generatePropsDestructuring, generateFactoryCallFromAttrs, generatePropsInterface, generateDtsContent, inferTypeFromDefault } from './schema-codegen';