@swarm.ing/pieui 2.0.23 → 2.0.25

package/dist/code/args.d.ts

@@ -1,6 +1,6 @@
 import type { ParsedArgs } from './types';
 export declare const parseArgs: (argv: string[]) => ParsedArgs;
-export type HelpScope = 'all' | 'login' | 'create' | 'init' | 'postbuild' | 'card' | 'card-remote' | 'page';
+export type HelpScope = 'all' | 'login' | 'create' | 'init' | 'postbuild' | 'card' | 'card-remote' | 'page' | 'self-upgrade';
 export declare const detectHelpScope: (argv: string[]) => HelpScope | null;
 export declare const printUsage: (scope?: HelpScope) => void;
 //# sourceMappingURL=args.d.ts.map

package/dist/code/args.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"args.d.ts","sourceRoot":"","sources":["../../src/code/args.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAOR,UAAU,EACb,MAAM,SAAS,CAAA;AAoJhB,eAAO,MAAM,SAAS,GAAI,MAAM,MAAM,EAAE,KAAG,UAqH1C,CAAA;AAED,MAAM,MAAM,SAAS,GACf,KAAK,GACL,OAAO,GACP,QAAQ,GACR,MAAM,GACN,WAAW,GACX,MAAM,GACN,aAAa,GACb,MAAM,CAAA;AAEZ,eAAO,MAAM,eAAe,GAAI,MAAM,MAAM,EAAE,KAAG,SAAS,GAAG,IAkB5D,CAAA;AA8KD,eAAO,MAAM,UAAU,GAAI,QAAO,SAAiB,SAsBlD,CAAA"}
+{"version":3,"file":"args.d.ts","sourceRoot":"","sources":["../../src/code/args.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAOR,UAAU,EACb,MAAM,SAAS,CAAA;AA8JhB,eAAO,MAAM,SAAS,GAAI,MAAM,MAAM,EAAE,KAAG,UAuI1C,CAAA;AAED,MAAM,MAAM,SAAS,GACf,KAAK,GACL,OAAO,GACP,QAAQ,GACR,MAAM,GACN,WAAW,GACX,MAAM,GACN,aAAa,GACb,MAAM,GACN,cAAc,CAAA;AAEpB,eAAO,MAAM,eAAe,GAAI,MAAM,MAAM,EAAE,KAAG,SAAS,GAAG,IAmB5D,CAAA;AAoMD,eAAO,MAAM,UAAU,GAAI,QAAO,SAAiB,SAwBlD,CAAA"}

package/dist/code/commands/add.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"add.d.ts","sourceRoot":"","sources":["../../../src/code/commands/add.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,mBAAmB,EAAE,aAAa,EAAE,MAAM,UAAU,CAAA;AA0C7D,eAAO,MAAM,UAAU,GACnB,eAAe,MAAM,EACrB,gBAAe,aAAmC,EAClD,UAAS,mBAAwB,SAmGpC,CAAA"}
+{"version":3,"file":"add.d.ts","sourceRoot":"","sources":["../../../src/code/commands/add.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,mBAAmB,EAAE,aAAa,EAAE,MAAM,UAAU,CAAA;AA8C7D,eAAO,MAAM,UAAU,GACnB,eAAe,MAAM,EACrB,gBAAe,aAAmC,EAClD,UAAS,mBAAwB,SAqGpC,CAAA"}

package/dist/code/commands/addEvent.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"addEvent.d.ts","sourceRoot":"","sources":["../../../src/code/commands/addEvent.ts"],"names":[],"mappings":"AAqFA,eAAO,MAAM,eAAe,GACxB,QAAQ,MAAM,EACd,eAAe,MAAM,EACrB,WAAW,MAAM,SA+IpB,CAAA"}
+{"version":3,"file":"addEvent.d.ts","sourceRoot":"","sources":["../../../src/code/commands/addEvent.ts"],"names":[],"mappings":"AAyFA,eAAO,MAAM,eAAe,GACxB,QAAQ,MAAM,EACd,eAAe,MAAM,EACrB,WAAW,MAAM,SAiJpB,CAAA"}

package/dist/code/commands/cardAddFromMeta.d.ts

@@ -0,0 +1,4 @@
+import type { ComponentType } from '../types';
+export declare const hasBackendSourceFor: (componentName: string) => boolean;
+export declare const cardAddFromMetaCommand: (componentName: string, componentType: ComponentType, fromRaw: string | undefined) => void;
+//# sourceMappingURL=cardAddFromMeta.d.ts.map

package/dist/code/commands/cardAddFromMeta.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cardAddFromMeta.d.ts","sourceRoot":"","sources":["../../../src/code/commands/cardAddFromMeta.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,aAAa,EAA2B,MAAM,UAAU,CAAA;AAgStE,eAAO,MAAM,mBAAmB,GAAI,eAAe,MAAM,KAAG,OAU3D,CAAA;AAED,eAAO,MAAM,sBAAsB,GAC/B,eAAe,MAAM,EACrB,eAAe,aAAa,EAC5B,SAAS,MAAM,GAAG,SAAS,KAC5B,IA+FF,CAAA"}

package/dist/code/commands/cardCheckSync.d.ts

@@ -0,0 +1,2 @@
+export declare const cardCheckSyncCommand: (componentName: string) => Promise<number>;
+//# sourceMappingURL=cardCheckSync.d.ts.map

package/dist/code/commands/cardCheckSync.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cardCheckSync.d.ts","sourceRoot":"","sources":["../../../src/code/commands/cardCheckSync.ts"],"names":[],"mappings":"AAmKA,eAAO,MAAM,oBAAoB,GAC7B,eAAe,MAAM,KACtB,OAAO,CAAC,MAAM,CAmBhB,CAAA"}

package/dist/code/commands/cardDumpMetadata.d.ts

@@ -0,0 +1,39 @@
+/**
+ * `pieui card dump-metadata <Name>` — emit PieMetadata JSON.
+ *
+ * This module is the orchestration layer. All introspection algorithms
+ * live in `code/introspection/` — see that package's JSDoc for inputs,
+ * outputs, and algorithmic assumptions of each piece.
+ */
+import type { PieMetadata } from '../types';
+/**
+ * Build the PieMetadata object for a component.
+ *
+ * INPUTS:
+ *   - `componentName`: the PascalCase card name. Must correspond to a
+ *     directory `<settings.componentsDir>/<componentName>/`.
+ *
+ * RETURNS: full PieMetadata object (see `types.ts`).
+ *
+ * ASSUMPTIONS:
+ *   - The component's data type follows naming convention
+ *     `<Name>Data` / `I<Name>Data` / `<Name>Props` (see findDataType).
+ *   - `<PieCard>` JSX usage is the source of truth for events; methods
+ *     must be an inline object literal (see extractEvents).
+ *   - Input variant is detected ONLY via `<PieCard stored={X}/>`
+ *     (see findInputType — policy decision in spec discussion).
+ *
+ * PIPELINE:
+ *   1. Glob component files (collectComponentFiles).
+ *   2. Build TS program/checker context (createSchemaContext).
+ *   3. Find props data type via naming convention.
+ *   4. Extract events strictly from `<PieCard methods={…}>`.
+ *   5. Recover each event handler's payload type.
+ *   6. Find input type via `<PieCard stored={X}/>`.
+ *   7. Split imports into packages / relativeImports.
+ */
+export declare const buildCardMetadata: (componentName: string) => PieMetadata;
+export declare const stringifyPieMetadata: (meta: PieMetadata) => string;
+/** CLI entry point. Builds metadata, writes to `outFile` or stdout. */
+export declare const cardDumpMetadataCommand: (componentName: string, outFile: string | undefined) => void;
+//# sourceMappingURL=cardDumpMetadata.d.ts.map

package/dist/code/commands/cardDumpMetadata.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cardDumpMetadata.d.ts","sourceRoot":"","sources":["../../../src/code/commands/cardDumpMetadata.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAiBH,OAAO,KAAK,EAAc,WAAW,EAAE,MAAM,UAAU,CAAA;AAwBvD;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,eAAO,MAAM,iBAAiB,GAAI,eAAe,MAAM,KAAG,WA6DzD,CAAA;AAED,eAAO,MAAM,oBAAoB,GAAI,MAAM,WAAW,KAAG,MAChC,CAAA;AAEzB,uEAAuE;AACvE,eAAO,MAAM,uBAAuB,GAChC,eAAe,MAAM,EACrB,SAAS,MAAM,GAAG,SAAS,KAC5B,IAWF,CAAA"}

package/dist/code/commands/create.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"create.d.ts","sourceRoot":"","sources":["../../../src/code/commands/create.ts"],"names":[],"mappings":"AA4FA,eAAO,MAAM,aAAa,GAAU,SAAS,MAAM,kBA+ClD,CAAA"}
+{"version":3,"file":"create.d.ts","sourceRoot":"","sources":["../../../src/code/commands/create.ts"],"names":[],"mappings":"AAgGA,eAAO,MAAM,aAAa,GAAU,SAAS,MAAM,kBAiDlD,CAAA"}

package/dist/code/commands/createPieApp.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"createPieApp.d.ts","sourceRoot":"","sources":["../../../src/code/commands/createPieApp.ts"],"names":[],"mappings":"AAmOA,eAAO,MAAM,mBAAmB,GAAI,SAAS,MAAM,SAuElD,CAAA"}
+{"version":3,"file":"createPieApp.d.ts","sourceRoot":"","sources":["../../../src/code/commands/createPieApp.ts"],"names":[],"mappings":"AAuOA,eAAO,MAAM,mBAAmB,GAAI,SAAS,MAAM,SAyElD,CAAA"}

package/dist/code/commands/init.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"init.d.ts","sourceRoot":"","sources":["../../../src/code/commands/init.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,WAAW,GAAU,QAAQ,MAAM,kBAkH/C,CAAA"}
+{"version":3,"file":"init.d.ts","sourceRoot":"","sources":["../../../src/code/commands/init.ts"],"names":[],"mappings":"AAOA,eAAO,MAAM,WAAW,GAAU,QAAQ,MAAM,kBAoH/C,CAAA"}

package/dist/code/commands/pageAdd.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"pageAdd.d.ts","sourceRoot":"","sources":["../../../src/code/commands/pageAdd.ts"],"names":[],"mappings":"AAoDA,eAAO,MAAM,cAAc,GAAI,UAAU,MAAM,SAoB9C,CAAA"}
+{"version":3,"file":"pageAdd.d.ts","sourceRoot":"","sources":["../../../src/code/commands/pageAdd.ts"],"names":[],"mappings":"AAwDA,eAAO,MAAM,cAAc,GAAI,UAAU,MAAM,SAsB9C,CAAA"}

package/dist/code/commands/remove.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"remove.d.ts","sourceRoot":"","sources":["../../../src/code/commands/remove.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,aAAa,GAAI,eAAe,MAAM,SAsDlD,CAAA"}
+{"version":3,"file":"remove.d.ts","sourceRoot":"","sources":["../../../src/code/commands/remove.ts"],"names":[],"mappings":"AAQA,eAAO,MAAM,aAAa,GAAI,eAAe,MAAM,SAwDlD,CAAA"}

package/dist/code/commands/selfUpgrade.d.ts

@@ -0,0 +1,2 @@
+export declare const selfUpgradeCommand: (override?: string) => Promise<void>;
+//# sourceMappingURL=selfUpgrade.d.ts.map

package/dist/code/commands/selfUpgrade.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"selfUpgrade.d.ts","sourceRoot":"","sources":["../../../src/code/commands/selfUpgrade.ts"],"names":[],"mappings":"AAmDA,eAAO,MAAM,kBAAkB,GAAU,WAAW,MAAM,KAAG,OAAO,CAAC,IAAI,CAwCxE,CAAA"}

package/dist/code/introspection/collectFiles.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Glob a component directory for source files relevant to introspection.
+ *
+ * Excludes everything that's not "real" component code: tests, snapshots,
+ * Storybook stories, mocks.
+ */
+/**
+ * Return absolute paths of `.ts`/`.tsx`/`.css` files belonging to a
+ * component, sorted, deduplicated.
+ *
+ * ASSUMES: `componentDir` is the absolute directory containing the
+ * component (e.g. `<cwd>/piecomponents/<Name>`).
+ *
+ * RETURNS: sorted absolute paths. Empty array if nothing matches.
+ *
+ * EXCLUDED:
+ *   - `**​/__tests__/**` / `**​/__snapshots__/**` / `**​/__mocks__/**`
+ *   - `*.test.{ts,tsx}` / `*.spec.{ts,tsx}`
+ *   - `*.stories.{ts,tsx}` (Storybook)
+ *
+ * EDGE CASES:
+ *   - Files outside `componentDir` are never included.
+ *   - `.css` files are listed but not parsed by downstream introspection
+ *     (they go into `files` for completeness).
+ */
+export declare const collectComponentFiles: (componentDir: string) => string[];
+//# sourceMappingURL=collectFiles.d.ts.map

package/dist/code/introspection/collectFiles.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"collectFiles.d.ts","sourceRoot":"","sources":["../../../src/code/introspection/collectFiles.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAKH;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,qBAAqB,GAAI,cAAc,MAAM,KAAG,MAAM,EAwBlE,CAAA"}

package/dist/code/introspection/errors.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Errors raised by TS introspection.
+ *
+ * Each error carries:
+ *   - the file being analysed (`sourceFile`)
+ *   - line/column when available
+ *   - a stack of contexts describing the location in the structure
+ *   - actionable hint about how to fix the source
+ *
+ * These propagate to the CLI without being caught — the whole point
+ * of the strict model is to surface unknown shapes loudly.
+ */
+export type IntrospectionErrorOptions = {
+    sourceFile?: string;
+    line?: number;
+    column?: number;
+    context?: string[];
+    hint?: string;
+};
+export declare class IntrospectionError extends Error {
+    sourceFile?: string;
+    line?: number;
+    column?: number;
+    context: string[];
+    hint?: string;
+    constructor(message: string, opts?: IntrospectionErrorOptions);
+    /** Push a context frame and return self (for try/catch rethrow). */
+    withContext(frame: string): IntrospectionError;
+    private bareMessage;
+}
+export declare const errorOptsFromNode: (sourceFile: any, node: any) => IntrospectionErrorOptions;
+//# sourceMappingURL=errors.d.ts.map

package/dist/code/introspection/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../../src/code/introspection/errors.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,MAAM,MAAM,yBAAyB,GAAG;IACpC,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,OAAO,CAAC,EAAE,MAAM,EAAE,CAAA;IAClB,IAAI,CAAC,EAAE,MAAM,CAAA;CAChB,CAAA;AAED,qBAAa,kBAAmB,SAAQ,KAAK;IACzC,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,OAAO,EAAE,MAAM,EAAE,CAAA;IACjB,IAAI,CAAC,EAAE,MAAM,CAAA;gBAED,OAAO,EAAE,MAAM,EAAE,IAAI,GAAE,yBAA8B;IAyBjE,oEAAoE;IACpE,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,kBAAkB;IAc9C,OAAO,CAAC,WAAW;CAWtB;AAkBD,eAAO,MAAM,iBAAiB,GAC1B,YAAY,GAAG,EACf,MAAM,GAAG,KACV,yBAGD,CAAA"}

package/dist/code/introspection/extractEvents.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Strict extraction of event names from `<PieCard methods={…}>` JSX.
+ *
+ * The contract is intentionally STRICT (asymmetric to the lenient
+ * Python side): `methods={…}` MUST be an inline object literal with
+ * static keys. Spread, variable references, computed keys → throws.
+ *
+ * Rationale: TS authors who pass `methods={pieMethods}` (a hook return)
+ * have no way for static analysis to know the event surface. We force
+ * the call site to spell out the keys so the registry is observable.
+ *
+ * Use case: produces the `events` field of PieMetadata.
+ */
+/**
+ * Extract the union of event names declared via `<PieCard methods={…}>`
+ * across the given files.
+ *
+ * ASSUMES: `files` are absolute paths to `.ts`/`.tsx` source files.
+ *
+ * RETURNS: sorted array of unique event names (object-literal keys).
+ *
+ * THROWS: Error with file:line if `methods={…}` is anything other than
+ * a plain inline object literal with static keys. Specifically:
+ *   - `methods={spread}` (Identifier initializer) — throws.
+ *   - `methods={{ ...other }}` (spread element) — throws.
+ *   - `methods={{ [key]: handler }}` (computed key) — throws.
+ *   - `methods={{ click: fn }}` (PropertyAssignment) — OK.
+ *   - `methods={{ click }}` (Shorthand) — OK, key is `"click"`.
+ *
+ * Strings ARE accepted as keys (`methods={{ "click-x": fn }}`).
+ */
+export declare const extractEvents: (files: string[]) => string[];
+//# sourceMappingURL=extractEvents.d.ts.map

package/dist/code/introspection/extractEvents.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"extractEvents.d.ts","sourceRoot":"","sources":["../../../src/code/introspection/extractEvents.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAoGH;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,aAAa,GAAI,OAAO,MAAM,EAAE,KAAG,MAAM,EA2DrD,CAAA"}

package/dist/code/introspection/extractEventsPayloads.d.ts

@@ -0,0 +1,94 @@
+/**
+ * Recover the TS type of each event handler's first parameter, then
+ * produce `eventsPropsCode` (source text) and `eventsPropsSchema` (JSON
+ * Schema) for use in PieMetadata.
+ *
+ * Event handlers can be declared in three forms — all are handled here:
+ *
+ *   1. Inline arrow / function expression:
+ *        methods={{ click: (e: ClickEvt) => doIt(e) }}
+ *
+ *   2. Shorthand property whose name matches a variable in scope:
+ *        const click = (e: ClickEvt) => doIt(e)
+ *        methods={{ click }}
+ *
+ *   3. Method declaration:
+ *        methods={{ click(e: ClickEvt) { doIt(e) } }}
+ *
+ * In all three the parameter's type annotation is the source of truth.
+ */
+import { type SchemaContext } from './schemaContext';
+import type { JSONSchema } from '../types';
+/**
+ * Follow a JSX shorthand or identifier reference back to the function
+ * declaration and return its first parameter node.
+ *
+ * ASSUMES: `identifier` is an AST `Identifier` node.
+ *
+ * RETURNS: the `Parameter` AST node, or `null` if:
+ *   - the symbol can't be resolved by the checker.
+ *   - the declaration isn't a function-like form we recognize.
+ *
+ * RESOLVES:
+ *   - `FunctionDeclaration` — `function foo(p) {}`
+ *   - `VariableDeclaration` initializer = ArrowFunction/FunctionExpr
+ *     — `const foo = (p) => …`
+ *   - `MethodDeclaration` / `MethodSignature`
+ *   - Alias symbols (re-exports) are unwrapped via `getAliasedSymbol`.
+ *
+ * KNOWN GAPS: `useCallback(fn)`, type-asserted (`fn as F`), wrapped in
+ * `useMemo` etc. — these reach a non-recognized declaration and return
+ * `null`. The event still appears in `events[]` but its schema/code
+ * stays empty.
+ */
+export declare const followIdentifierToFunction: (ctx: SchemaContext, identifier: any) => any | null;
+/**
+ * Render a function parameter as `{ code, schema }`.
+ *
+ * ASSUMES: `parameter` is an AST `Parameter` node; `sourceFile` is the
+ * `SourceFile` containing it (for `getText` to return original text).
+ *
+ * RETURNS:
+ *   - `code`: the explicit type annotation if present (e.g.
+ *     `"{ tab: string }"`), or the checker-inferred type as a string
+ *     when the parameter is untyped.
+ *   - `schema`: JSON Schema. Strategy:
+ *       1. If annotation is a `TypeReferenceNode` (`Foo`) — try
+ *          `buildSchemaForType(ctx, "Foo")` (via typescript-json-schema).
+ *       2. Otherwise — fall back to `typeToSchema(checker.getTypeAtLocation(typeNode))`
+ *          which walks the TS Type directly (handles inline literals).
+ *   - `null` schema when neither path produces a result.
+ */
+export declare const schemaForParameter: (ctx: SchemaContext, parameter: any, sourceFile: any) => {
+    code: string;
+    schema: JSONSchema | null;
+};
+/**
+ * Walk `<PieCard methods={…}>` JSX literals in every file, restrict to
+ * the previously-extracted `events` set, and recover each handler's
+ * parameter type as `{ code, schema }`.
+ *
+ * ASSUMES:
+ *   - `events` is the list of event-name strings already discovered by
+ *     `extractEvents` (which itself enforces the inline-object-literal
+ *     rule). This pass tolerates the same shape — anything else is
+ *     skipped without throwing.
+ *   - `ctx` includes all `files` (so `getSourceFile()` succeeds).
+ *
+ * RETURNS:
+ *   - `code`: `{ eventName: typeText }`. May be empty for events whose
+ *     handler can't be statically resolved (e.g. `useCallback`-wrapped).
+ *   - `schema`: `{ eventName: JSONSchema }`. Same caveat.
+ *
+ * EDGE CASES:
+ *   - Spread / variable `methods={…}` is silently skipped here
+ *     (because `extractEvents` already strictly rejected those, the
+ *     unreachable case is defensive).
+ *   - Events listed in `events[]` but not present as keys in the JSX
+ *     are absent from the result (no synthetic entry).
+ */
+export declare const extractEventsPayloads: (ctx: SchemaContext, files: string[], events: string[]) => {
+    code: Record<string, string>;
+    schema: Record<string, JSONSchema>;
+};
+//# sourceMappingURL=extractEventsPayloads.d.ts.map

package/dist/code/introspection/extractEventsPayloads.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"extractEventsPayloads.d.ts","sourceRoot":"","sources":["../../../src/code/introspection/extractEventsPayloads.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAIH,OAAO,EAAsB,KAAK,aAAa,EAAE,MAAM,iBAAiB,CAAA;AAExE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,UAAU,CAAA;AAK1C;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,0BAA0B,GACnC,KAAK,aAAa,EAClB,YAAY,GAAG,KAChB,GAAG,GAAG,IAmCR,CAAA;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,kBAAkB,GAC3B,KAAK,aAAa,EAClB,WAAW,GAAG,EACd,YAAY,GAAG,KAChB;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,UAAU,GAAG,IAAI,CAAA;CAsB3C,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,eAAO,MAAM,qBAAqB,GAC9B,KAAK,aAAa,EAClB,OAAO,MAAM,EAAE,EACf,QAAQ,MAAM,EAAE,KACjB;IAAE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,CAAA;CAmGpE,CAAA"}

package/dist/code/introspection/extractImports.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Split a component's import graph into `relativeImports` (project-local
+ * file paths) and `packages` (third-party deps with version specs from
+ * package.json).
+ *
+ * Resolution strategy:
+ *   1. `ts.resolveModuleName` with a ts.sys-backed host.
+ *   2. Manual fallback through `tsconfig.json` paths aliases for cases
+ *      where Bundler resolution doesn't match (e.g. `@/components/*`).
+ *
+ * Output classification:
+ *   - resolved path INSIDE cwd AND NOT under any `node_modules/` →
+ *     `relativeImports`.
+ *   - everything else → `packages`, with version copied verbatim from
+ *     `package.json` deps (dev/peer/optional included) when known.
+ */
+export type ImportSplit = {
+    relativeImports: string[];
+    packages: string[];
+};
+/**
+ * Walk imports in each file and classify them.
+ *
+ * ASSUMES:
+ *   - `files` are absolute paths.
+ *   - `cwd` (default: `process.cwd()`) is the project root containing
+ *     `tsconfig.json` and `package.json`.
+ *
+ * RETURNS:
+ *   - `relativeImports`: sorted absolute paths to project-local files.
+ *     `node_modules` paths are excluded — they're classified as packages.
+ *   - `packages`: sorted strings ready for `bun add` / `npm install`.
+ *     Format is either `name` (no version found) or `name@<spec>`
+ *     where `<spec>` is the verbatim entry from package.json.
+ *
+ * EDGE CASES:
+ *   - Symlinks INSIDE cwd → followed to realpath; if realpath is still
+ *     inside cwd, kept as relativeImport; if outside, dropped as package.
+ *   - Path-aliased imports (`@/x`) when `paths` is in tsconfig.json:
+ *     resolved via `resolveByTsconfigPaths` if `ts.resolveModuleName`
+ *     fails.
+ *   - Bare specs starting with `.` or `/` that don't resolve to a real
+ *     file → silently dropped (consumer can't add a missing file).
+ */
+export declare const extractImports: (files: string[], cwd?: string) => ImportSplit;
+//# sourceMappingURL=extractImports.d.ts.map

package/dist/code/introspection/extractImports.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"extractImports.d.ts","sourceRoot":"","sources":["../../../src/code/introspection/extractImports.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AA0NH,MAAM,MAAM,WAAW,GAAG;IACtB,eAAe,EAAE,MAAM,EAAE,CAAA;IACzB,QAAQ,EAAE,MAAM,EAAE,CAAA;CACrB,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,eAAO,MAAM,cAAc,GACvB,OAAO,MAAM,EAAE,EACf,MAAK,MAAsB,KAC5B,WA6DF,CAAA"}

package/dist/code/introspection/findDataType.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Locate the TypeScript `<Name>Data` declaration that defines a card's
+ * props shape, and the `pathname*` field names within it (ajaxList).
+ *
+ * The pieui convention: a card named `Foo` has its props described by
+ * `interface FooData { ... }`. Alternatives `IFooData` and `FooProps`
+ * are also recognized to accommodate older conventions.
+ */
+import { type SchemaContext } from './schemaContext';
+/**
+ * Try to find the card's data type by naming convention.
+ *
+ * ASSUMES: `componentName` is the PascalCase card name (e.g. `BoxCard`).
+ *
+ * RETURNS: `{ typeName, declaration }` for the first match, or `null`.
+ *
+ * TYPE NAME CANDIDATES, in priority order:
+ *   1. `<componentName>Data`   — canonical pattern
+ *   2. `I<componentName>Data`  — Hungarian variant
+ *   3. `<componentName>Props`  — older code uses this for the data shape
+ *
+ * USAGE: pass the returned `declaration` to `getText()` for `propsCode`
+ * and `extractAjaxList()` for the `ajaxList` field.
+ */
+export declare const findComponentDataTypeForName: (ctx: SchemaContext, componentName: string) => {
+    typeName: string;
+    declaration: any;
+};
+/**
+ * Extract ajax-pathname field names directly declared on the props
+ * interface or type alias.
+ *
+ * ASSUMES: `declaration` is an `InterfaceDeclaration` or
+ * `TypeAliasDeclaration` (typically the one returned by
+ * `findComponentDataTypeForName`).
+ *
+ * RETURNS: sorted unique field names whose identifier starts with
+ * `pathname`. Includes `pathname` itself plus camelCase variants
+ * (`pathnameClick`, `pathnameDelete`, ...).
+ *
+ * EDGE CASE: NESTED property signatures are also walked via
+ * `ts.forEachChild`. Future improvement could restrict to direct
+ * children of the type body to avoid bleed-through from anonymous
+ * inline types (cf. Python side which already limits to direct fields).
+ */
+/**
+ * Direct members of the props type that start with `pathname`.
+ *
+ * Restricted to DIRECT members of the type body — nested object types
+ * with their own `pathname*` keys are NOT included to avoid spurious
+ * ajax fields bleeding from inner shapes.
+ *
+ * For interface declarations: walks `members`.
+ * For type aliases of TypeLiteral: walks `members`.
+ * For type aliases of union/intersection/other: returns []. To declare
+ * ajax fields, the props type must have a literal object shape.
+ */
+export declare const extractAjaxList: (declaration: any) => string[];
+//# sourceMappingURL=findDataType.d.ts.map

package/dist/code/introspection/findDataType.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"findDataType.d.ts","sourceRoot":"","sources":["../../../src/code/introspection/findDataType.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAIH,OAAO,EAEH,KAAK,aAAa,EACrB,MAAM,iBAAiB,CAAA;AAExB;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,4BAA4B,GACrC,KAAK,aAAa,EAClB,eAAe,MAAM,KACtB;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,WAAW,EAAE,GAAG,CAAA;CAmBtC,CAAA;AAED;;;;;;;;;;;;;;;;GAgBG;AACH;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,eAAe,GAAI,aAAa,GAAG,KAAG,MAAM,EAwBxD,CAAA"}

package/dist/code/introspection/findInputType.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Locate the type passed to `<PieCard stored={X} />` in JSX.
+ *
+ * Policy decision (per Policy C in the spec discussion): the TS side
+ * recognises an Input variant ONLY through the `stored` prop. No
+ * naming-convention fallback. If the card uses a hidden `<input>` element
+ * instead of `stored`, that's intentional and the metadata reports no
+ * input shape.
+ */
+import type { SchemaContext } from './schemaContext';
+/**
+ * Walk JSX `<PieCard stored={X}/>` attributes and recover the type of `X`.
+ *
+ * ASSUMES:
+ *   - `ctx` was built with files that include `<PieCard>` JSX usage.
+ *   - `files` is the list of files to scan (typically the component's
+ *     own source files).
+ *
+ * RETURNS:
+ *   - `{ typeName, declaration }` of the type alias / interface that
+ *     types the `stored` expression, on first hit.
+ *   - `null` if no `<PieCard stored=…>` is found in any file, or if the
+ *     stored expression has no resolvable named type.
+ *
+ * ALGORITHM:
+ *   1. For each JSX `<PieCard>` element, look at attribute `stored`.
+ *   2. If its initializer is `{expr}`, ask the checker for `expr`'s
+ *      type, then for that type's alias symbol or value symbol.
+ *   3. Take the first declaration that's an Interface/TypeAlias.
+ *
+ * EDGE CASES:
+ *   - `<PieCard stored={anonymousObject}/>` where the inline object has
+ *     no named type → returns `null`. Use a named interface or
+ *     `as InputXxx` for the metadata to pick it up.
+ *   - PieCard imported as a different name (`import { PieCard as Foo }`)
+ *     → not detected. The tag-name check is strict on `"PieCard"`.
+ */
+export declare const findStoredAttributeType: (ctx: SchemaContext, files: string[]) => {
+    typeName: string;
+    declaration: any;
+} | null;
+//# sourceMappingURL=findInputType.d.ts.map

package/dist/code/introspection/findInputType.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"findInputType.d.ts","sourceRoot":"","sources":["../../../src/code/introspection/findInputType.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAIH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAA;AAKpD;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,eAAO,MAAM,uBAAuB,GAChC,KAAK,aAAa,EAClB,OAAO,MAAM,EAAE,KAChB;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,WAAW,EAAE,GAAG,CAAA;CAAE,GAAG,IAgE3C,CAAA"}

package/dist/code/introspection/index.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Introspection algorithms for `pieui card dump-metadata` and `check-sync`.
+ *
+ * Each submodule documents its inputs, assumptions, output shape, and
+ * algorithmic approach via per-function JSDoc.
+ *
+ * Public surface:
+ *
+ *   schemaContext:
+ *     - createSchemaContext(files): SchemaContext
+ *     - findTypeDeclaration(program, checker, name): { symbol, declaration } | null
+ *     - buildSchemaForType(ctx, typeName): JSONSchema | null
+ *
+ *   typeToSchema:
+ *     - typeToSchema(tsType, checker): JSONSchema
+ *
+ *   collectFiles:
+ *     - collectComponentFiles(componentDir): string[]
+ *
+ *   extractImports:
+ *     - extractImports(files, cwd?): { relativeImports, packages }
+ *
+ *   extractEvents:
+ *     - extractEvents(files): string[]    // strict: throws on non-literal
+ *
+ *   extractEventsPayloads:
+ *     - followIdentifierToFunction(ctx, ident): Parameter | null
+ *     - schemaForParameter(ctx, param, sourceFile): { code, schema }
+ *     - extractEventsPayloads(ctx, files, events): { code, schema }
+ *
+ *   findDataType:
+ *     - findComponentDataTypeForName(ctx, name): { typeName, declaration } | null
+ *     - extractAjaxList(declaration): string[]
+ *
+ *   findInputType:
+ *     - findStoredAttributeType(ctx, files): { typeName, declaration } | null
+ */
+export { IntrospectionError } from './errors';
+export { createSchemaContext, findTypeDeclaration, buildSchemaForType, type SchemaContext, } from './schemaContext';
+export { typeToSchema } from './typeToSchema';
+export { collectComponentFiles } from './collectFiles';
+export { extractImports, type ImportSplit } from './extractImports';
+export { extractEvents } from './extractEvents';
+export { followIdentifierToFunction, schemaForParameter, extractEventsPayloads, } from './extractEventsPayloads';
+export { findComponentDataTypeForName, extractAjaxList, } from './findDataType';
+export { findStoredAttributeType } from './findInputType';
+//# sourceMappingURL=index.d.ts.map

package/dist/code/introspection/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/code/introspection/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AAEH,OAAO,EAAE,kBAAkB,EAAE,MAAM,UAAU,CAAA;AAC7C,OAAO,EACH,mBAAmB,EACnB,mBAAmB,EACnB,kBAAkB,EAClB,KAAK,aAAa,GACrB,MAAM,iBAAiB,CAAA;AACxB,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAA;AAC7C,OAAO,EAAE,qBAAqB,EAAE,MAAM,gBAAgB,CAAA;AACtD,OAAO,EAAE,cAAc,EAAE,KAAK,WAAW,EAAE,MAAM,kBAAkB,CAAA;AACnE,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAA;AAC/C,OAAO,EACH,0BAA0B,EAC1B,kBAAkB,EAClB,qBAAqB,GACxB,MAAM,yBAAyB,CAAA;AAChC,OAAO,EACH,4BAA4B,EAC5B,eAAe,GAClB,MAAM,gBAAgB,CAAA;AACvB,OAAO,EAAE,uBAAuB,EAAE,MAAM,iBAAiB,CAAA"}

package/dist/code/introspection/schemaContext.d.ts

@@ -0,0 +1,69 @@
+/**
+ * TypeScript compiler context for schema generation.
+ *
+ * Wraps `typescript-json-schema`'s program/checker/generator triple so
+ * other introspection helpers can resolve named types into JSON Schemas
+ * without each carrying its own copy of the compiler setup.
+ *
+ * The CLI's `cli-schema.d.ts` is always injected as the first file so
+ * built-in helper types are visible to the generator.
+ */
+import type { JSONSchema } from '../types';
+export type SchemaContext = {
+    program: any;
+    checker: any;
+    generator: any;
+};
+/**
+ * Build a `SchemaContext` from a list of source files.
+ *
+ * ASSUMES:
+ *   - `files` are absolute paths (`.ts` or `.tsx`).
+ *   - The TS compiler can read them with the default options below.
+ *
+ * RETURNS: an opaque context that callers pass to
+ * `findTypeDeclaration` and `buildSchemaForType`. The generator inside
+ * comes from `typescript-json-schema` and respects `strictNullChecks`,
+ * `noExtraProps: true`, and `ignoreErrors: true` (so partially-broken
+ * files still yield best-effort schemas).
+ */
+export declare const createSchemaContext: (files: string[]) => SchemaContext;
+/**
+ * Find an interface or type-alias declaration by name across all
+ * source files in the program.
+ *
+ * ASSUMES: `program` was built by `createSchemaContext` (i.e. has the
+ * relevant files loaded).
+ *
+ * RETURNS: `{ symbol, declaration }` for the first matching
+ * InterfaceDeclaration or TypeAliasDeclaration; `null` if not found.
+ *
+ * ALGORITHM: linear walk over every non-`.d.ts` source file, DFS into
+ * the AST. Returns at first hit; declaration files are skipped because
+ * we want user-declared types only.
+ */
+export declare const findTypeDeclaration: (program: any, checker: any, typeName: string) => {
+    symbol: any;
+    declaration: any;
+} | null;
+/**
+ * Build a JSON Schema for a named TS type (interface or type alias).
+ *
+ * ASSUMES: `typeName` is the identifier name of a declared type
+ * reachable from any source file in the context.
+ *
+ * RETURNS:
+ *   - the JSON Schema produced by `typescript-json-schema`, then
+ *     post-processed by `patchSchemaForType` so that special types like
+ *     `CSSProperties` collapse to `{ type: "object", additionalProperties: true }`.
+ *   - `null` if the generator fails or the type isn't found.
+ *
+ * ALGORITHM:
+ *   1. `generator.getSchemaForSymbol(typeName)` produces the raw schema.
+ *   2. `findTypeDeclaration` locates the declaration node so the
+ *      post-processor can walk it with the checker.
+ *   3. `patchSchemaForType` mutates the schema to fix known
+ *      `typescript-json-schema` quirks (CSSProperties, etc.).
+ */
+export declare const buildSchemaForType: (ctx: SchemaContext, typeName: string) => JSONSchema | null;
+//# sourceMappingURL=schemaContext.d.ts.map

package/dist/code/introspection/schemaContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schemaContext.d.ts","sourceRoot":"","sources":["../../../src/code/introspection/schemaContext.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAKH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,UAAU,CAAA;AAE1C,MAAM,MAAM,aAAa,GAAG;IACxB,OAAO,EAAE,GAAG,CAAA;IACZ,OAAO,EAAE,GAAG,CAAA;IACZ,SAAS,EAAE,GAAG,CAAA;CACjB,CAAA;AAaD;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,mBAAmB,GAAI,OAAO,MAAM,EAAE,KAAG,aA2BrD,CAAA;AAED;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,mBAAmB,GAC5B,SAAS,GAAG,EACZ,SAAS,GAAG,EACZ,UAAU,MAAM,KACjB;IAAE,MAAM,EAAE,GAAG,CAAC;IAAC,WAAW,EAAE,GAAG,CAAA;CAAE,GAAG,IAuBtC,CAAA;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,kBAAkB,GAC3B,KAAK,aAAa,EAClB,UAAU,MAAM,KACjB,UAAU,GAAG,IAiBf,CAAA"}