@cosmicdrift/kumiko-framework 0.327.0 → 0.328.1

package/dist/engine/feature-ast/extractors/round2.js

@@ -0,0 +1,158 @@
+import { SyntaxKind } from "ts-morph";
+import { describeUnknownFieldType, findUnknownEntityFieldTypes } from "../entity-field-types.js";
+import { sourceLocationFromNode } from "../source-location.js";
+import { fail, isPlainObject, ok, readDataLiteralNode, readNameLiteral, readNameOrRef, } from "./shared.js";
+export function extractEntity(call, sourceFile) {
+    const args = call.getArguments();
+    const first = args[0];
+    if (!first) {
+        return fail("entity", sourceLocationFromNode(call, sourceFile), "expected at least one argument");
+    }
+    const obj = first.asKind(SyntaxKind.ObjectLiteralExpression);
+    if (obj && args.length === 1) {
+        const nameInit = obj
+            .getProperty("name")
+            ?.asKind(SyntaxKind.PropertyAssignment)
+            ?.getInitializer()
+            ?.asKind(SyntaxKind.StringLiteral);
+        if (!nameInit) {
+            return fail("entity", sourceLocationFromNode(call, sourceFile), "object form requires a string-literal `name` property");
+        }
+        const definition = readDataLiteralNode(obj);
+        if (!isPlainObject(definition)) {
+            return fail("entity", sourceLocationFromNode(call, sourceFile), "definition could not be read as a plain object (contains functions or identifiers)");
+        }
+        const { name: _name, ...defWithoutName } = definition;
+        const unknownTypes = findUnknownEntityFieldTypes(defWithoutName);
+        const firstUnknown = unknownTypes[0];
+        if (firstUnknown) {
+            return fail("entity", sourceLocationFromNode(call, sourceFile), `definition.fields.${firstUnknown.fieldName}.type: ${describeUnknownFieldType(firstUnknown)}`);
+        }
+        return ok({
+            kind: "entity",
+            source: sourceLocationFromNode(call, sourceFile),
+            entityName: nameInit.getLiteralValue(),
+            // Field-type membership is checked above; the cast is the extractor's
+            // existing narrowing contract (readDataLiteralNode returns unknown).
+            definition: defWithoutName,
+        });
+    }
+    const entityName = readNameLiteral(first);
+    if (entityName === undefined) {
+        return fail("entity", sourceLocationFromNode(call, sourceFile), "first argument must be a string literal name, or an identifier resolving to one (or use the object form)");
+    }
+    const defArg = args[1];
+    if (!defArg) {
+        return fail("entity", sourceLocationFromNode(call, sourceFile), "expected a definition object as second argument");
+    }
+    const definition = readDataLiteralNode(defArg);
+    if (!isPlainObject(definition)) {
+        return fail("entity", sourceLocationFromNode(call, sourceFile), "definition could not be read as a plain object (contains functions or identifiers)");
+    }
+    const unknownTypes = findUnknownEntityFieldTypes(definition);
+    const firstUnknown = unknownTypes[0];
+    if (firstUnknown) {
+        return fail("entity", sourceLocationFromNode(call, sourceFile), `definition.fields.${firstUnknown.fieldName}.type: ${describeUnknownFieldType(firstUnknown)}`);
+    }
+    return ok({
+        kind: "entity",
+        source: sourceLocationFromNode(call, sourceFile),
+        entityName,
+        definition: definition,
+    });
+}
+export function extractRelation(call, sourceFile) {
+    const args = call.getArguments();
+    const first = args[0];
+    if (!first) {
+        return fail("relation", sourceLocationFromNode(call, sourceFile), "expected at least one argument");
+    }
+    const obj = first.asKind(SyntaxKind.ObjectLiteralExpression);
+    if (obj && args.length === 1) {
+        const entityInit = obj
+            .getProperty("entity")
+            ?.asKind(SyntaxKind.PropertyAssignment)
+            ?.getInitializer();
+        if (!entityInit) {
+            return fail("relation", sourceLocationFromNode(call, sourceFile), "object form requires an `entity` property");
+        }
+        const entityName = readNameOrRef(entityInit);
+        if (!entityName) {
+            return fail("relation", sourceLocationFromNode(call, sourceFile), '`entity` must be a string literal or `{ name: "..." }` ref');
+        }
+        const nameInit = obj
+            .getProperty("name")
+            ?.asKind(SyntaxKind.PropertyAssignment)
+            ?.getInitializer()
+            ?.asKind(SyntaxKind.StringLiteral);
+        if (!nameInit) {
+            return fail("relation", sourceLocationFromNode(call, sourceFile), "object form requires a string-literal `name` property");
+        }
+        const definition = readDataLiteralNode(obj);
+        if (!isPlainObject(definition)) {
+            return fail("relation", sourceLocationFromNode(call, sourceFile), "definition could not be read as a plain object");
+        }
+        const { entity: _e, name: _n, ...defWithoutCarriers } = definition;
+        return ok({
+            kind: "relation",
+            source: sourceLocationFromNode(call, sourceFile),
+            entityName,
+            relationName: nameInit.getLiteralValue(),
+            definition: defWithoutCarriers,
+        });
+    }
+    const entityName = readNameOrRef(first);
+    if (!entityName) {
+        return fail("relation", sourceLocationFromNode(call, sourceFile), 'first argument must be a string literal or an inline { name: "..." } object (or use the object form)');
+    }
+    const relationNameArg = args[1];
+    const relationName = relationNameArg && readNameLiteral(relationNameArg);
+    if (!relationName) {
+        return fail("relation", sourceLocationFromNode(call, sourceFile), "second argument must be a string literal relation name, or an identifier resolving to one");
+    }
+    const defArg = args[2];
+    if (!defArg) {
+        return fail("relation", sourceLocationFromNode(call, sourceFile), "expected a definition object as third argument");
+    }
+    const definition = readDataLiteralNode(defArg);
+    if (!isPlainObject(definition)) {
+        return fail("relation", sourceLocationFromNode(call, sourceFile), "definition could not be read as a plain object");
+    }
+    return ok({
+        kind: "relation",
+        source: sourceLocationFromNode(call, sourceFile),
+        entityName,
+        relationName,
+        definition: definition,
+    });
+}
+export function extractNav(call, sourceFile) {
+    const arg = call.getArguments()[0];
+    if (!arg) {
+        return fail("nav", sourceLocationFromNode(call, sourceFile), "expected a NavDefinition object as first argument");
+    }
+    const definition = readDataLiteralNode(arg);
+    if (!isPlainObject(definition)) {
+        return fail("nav", sourceLocationFromNode(call, sourceFile), "definition could not be read as a plain object");
+    }
+    return ok({
+        kind: "nav",
+        source: sourceLocationFromNode(call, sourceFile),
+        definition: definition,
+    });
+}
+export function extractWorkspace(call, sourceFile) {
+    const arg = call.getArguments()[0];
+    if (!arg) {
+        return fail("workspace", sourceLocationFromNode(call, sourceFile), "expected a WorkspaceDefinition object as first argument");
+    }
+    const definition = readDataLiteralNode(arg);
+    if (!isPlainObject(definition)) {
+        return fail("workspace", sourceLocationFromNode(call, sourceFile), "definition could not be read as a plain object");
+    }
+    return ok({
+        kind: "workspace",
+        source: sourceLocationFromNode(call, sourceFile),
+        definition: definition,
+    });
+}

package/dist/engine/feature-ast/extractors/round3.d.ts

@@ -0,0 +1,22 @@
+import type { CallExpression, SourceFile } from "ts-morph";
+import type { ClaimKeyType } from "../../types/handlers.js";
+import type { ParseError } from "../parse.js";
+import type { ClaimKeyPattern, ConfigPattern, MetricPattern, ReferenceDataPattern, SecretPattern, TranslationsPattern, UseExtensionPattern } from "../patterns.js";
+import { type ExtractOutput } from "./shared.js";
+export type NamedOptionsResult = {
+    readonly kind: "ok";
+    readonly name: string;
+    readonly options: Record<string, unknown>;
+} | {
+    readonly kind: "error";
+    readonly error: ParseError;
+};
+export declare function readNamedOptions(call: CallExpression, sourceFile: SourceFile, methodName: string): NamedOptionsResult;
+export declare function extractConfig(call: CallExpression, sourceFile: SourceFile): ExtractOutput<ConfigPattern>;
+export declare function extractTranslations(call: CallExpression, sourceFile: SourceFile): ExtractOutput<TranslationsPattern>;
+export declare function extractMetric(call: CallExpression, sourceFile: SourceFile): ExtractOutput<MetricPattern>;
+export declare function extractSecret(call: CallExpression, sourceFile: SourceFile): ExtractOutput<SecretPattern>;
+export declare function isClaimKeyType(value: unknown): value is ClaimKeyType;
+export declare function extractClaimKey(call: CallExpression, sourceFile: SourceFile): ExtractOutput<ClaimKeyPattern>;
+export declare function extractReferenceData(call: CallExpression, sourceFile: SourceFile): ExtractOutput<ReferenceDataPattern>;
+export declare function extractUseExtension(call: CallExpression, sourceFile: SourceFile): ExtractOutput<UseExtensionPattern>;

package/dist/engine/feature-ast/extractors/round3.js

@@ -0,0 +1,280 @@
+import { SyntaxKind } from "ts-morph";
+import { sourceLocationFromNode } from "../source-location.js";
+import { fail, isPlainObject, ok, readDataLiteralNode, readNameLiteral, readNameLiteralRef, readNameOrRef, } from "./shared.js";
+export function readNamedOptions(call, sourceFile, methodName) {
+    const args = call.getArguments();
+    const first = args[0];
+    if (!first) {
+        return fail(methodName, sourceLocationFromNode(call, sourceFile), "expected at least one argument");
+    }
+    const obj = first.asKind(SyntaxKind.ObjectLiteralExpression);
+    if (obj && args.length === 1) {
+        const nameInit = obj
+            .getProperty("name")
+            ?.asKind(SyntaxKind.PropertyAssignment)
+            ?.getInitializer()
+            ?.asKind(SyntaxKind.StringLiteral);
+        if (!nameInit) {
+            return fail(methodName, sourceLocationFromNode(call, sourceFile), "object form requires a string-literal `name` property");
+        }
+        const data = readDataLiteralNode(obj);
+        if (!isPlainObject(data)) {
+            return fail(methodName, sourceLocationFromNode(call, sourceFile), "argument could not be read as a plain object");
+        }
+        const { name: _name, ...optionsWithoutName } = data;
+        return { kind: "ok", name: nameInit.getLiteralValue(), options: optionsWithoutName };
+    }
+    const name = readNameLiteral(first);
+    if (name === undefined) {
+        return fail(methodName, sourceLocationFromNode(call, sourceFile), "first argument must be a string literal name, or an identifier resolving to one (or use the object form)");
+    }
+    const optionsArg = args[1];
+    if (!optionsArg) {
+        return fail(methodName, sourceLocationFromNode(call, sourceFile), "expected an options object as second argument");
+    }
+    const options = readDataLiteralNode(optionsArg);
+    if (!isPlainObject(options)) {
+        return fail(methodName, sourceLocationFromNode(call, sourceFile), "options could not be read as a plain object");
+    }
+    return { kind: "ok", name, options };
+}
+export function extractConfig(call, sourceFile) {
+    const arg = call.getArguments()[0];
+    if (!arg) {
+        return fail("config", sourceLocationFromNode(call, sourceFile), "expected `{ keys: { ... } }` as first argument");
+    }
+    const obj = readDataLiteralNode(arg);
+    if (!isPlainObject(obj)) {
+        return fail("config", sourceLocationFromNode(call, sourceFile), "argument could not be read as a plain object");
+    }
+    const keys = obj["keys"];
+    if (!isPlainObject(keys)) {
+        return fail("config", sourceLocationFromNode(call, sourceFile), "missing or non-object `keys` property");
+    }
+    return ok({
+        kind: "config",
+        source: sourceLocationFromNode(call, sourceFile),
+        keys: keys,
+    });
+}
+export function extractTranslations(call, sourceFile) {
+    const arg = call.getArguments()[0];
+    if (!arg) {
+        return fail("translations", sourceLocationFromNode(call, sourceFile), "expected `{ keys: { ... } }` as first argument");
+    }
+    const obj = readDataLiteralNode(arg);
+    if (!isPlainObject(obj)) {
+        return fail("translations", sourceLocationFromNode(call, sourceFile), "argument could not be read as a plain object");
+    }
+    const keys = obj["keys"];
+    if (!isPlainObject(keys)) {
+        return fail("translations", sourceLocationFromNode(call, sourceFile), "missing or non-object `keys` property");
+    }
+    return ok({
+        kind: "translations",
+        source: sourceLocationFromNode(call, sourceFile),
+        keys: keys,
+    });
+}
+export function extractMetric(call, sourceFile) {
+    const parsed = readNamedOptions(call, sourceFile, "metric");
+    if (parsed.kind === "error")
+        return parsed;
+    return ok({
+        kind: "metric",
+        source: sourceLocationFromNode(call, sourceFile),
+        shortName: parsed.name,
+        options: parsed.options,
+    });
+}
+export function extractSecret(call, sourceFile) {
+    const parsed = readNamedOptions(call, sourceFile, "secret");
+    if (parsed.kind === "error")
+        return parsed;
+    return ok({
+        kind: "secret",
+        source: sourceLocationFromNode(call, sourceFile),
+        shortName: parsed.name,
+        options: parsed.options,
+    });
+}
+export function isClaimKeyType(value) {
+    return (value === "string" ||
+        value === "number" ||
+        value === "boolean" ||
+        value === "string[]" ||
+        value === "object");
+}
+export function extractClaimKey(call, sourceFile) {
+    const parsed = readNamedOptions(call, sourceFile, "claimKey");
+    if (parsed.kind === "error")
+        return parsed;
+    const claimType = parsed.options["type"];
+    if (!isClaimKeyType(claimType)) {
+        return fail("claimKey", sourceLocationFromNode(call, sourceFile), 'type must be one of "string" | "number" | "boolean" | "string[]" | "object"');
+    }
+    return ok({
+        kind: "claimKey",
+        source: sourceLocationFromNode(call, sourceFile),
+        shortName: parsed.name,
+        claimType,
+    });
+}
+export function extractReferenceData(call, sourceFile) {
+    const args = call.getArguments();
+    const first = args[0];
+    if (!first) {
+        return fail("referenceData", sourceLocationFromNode(call, sourceFile), "expected at least one argument");
+    }
+    const obj = first.asKind(SyntaxKind.ObjectLiteralExpression);
+    if (obj && args.length === 1) {
+        const entityInit = obj
+            .getProperty("entity")
+            ?.asKind(SyntaxKind.PropertyAssignment)
+            ?.getInitializer();
+        if (!entityInit) {
+            return fail("referenceData", sourceLocationFromNode(call, sourceFile), "object form requires an `entity` property");
+        }
+        const entityName = readNameOrRef(entityInit);
+        if (!entityName) {
+            return fail("referenceData", sourceLocationFromNode(call, sourceFile), '`entity` must be a string literal or `{ name: "..." }` ref');
+        }
+        const dataInit = obj
+            .getProperty("data")
+            ?.asKind(SyntaxKind.PropertyAssignment)
+            ?.getInitializer();
+        if (!dataInit) {
+            return fail("referenceData", sourceLocationFromNode(call, sourceFile), "object form requires a `data` property");
+        }
+        const data = readDataLiteralNode(dataInit);
+        if (!Array.isArray(data) || !data.every(isPlainObject)) {
+            return fail("referenceData", sourceLocationFromNode(call, sourceFile), "data must be an array of plain objects");
+        }
+        let upsertKey;
+        const upsertKeyInit = obj
+            .getProperty("upsertKey")
+            ?.asKind(SyntaxKind.PropertyAssignment)
+            ?.getInitializer()
+            ?.asKind(SyntaxKind.StringLiteral);
+        if (upsertKeyInit) {
+            upsertKey = upsertKeyInit.getLiteralValue();
+        }
+        return ok({
+            kind: "referenceData",
+            source: sourceLocationFromNode(call, sourceFile),
+            entityName,
+            data: data,
+            ...(upsertKey !== undefined && { upsertKey }),
+        });
+    }
+    const entityName = readNameOrRef(first);
+    if (!entityName) {
+        return fail("referenceData", sourceLocationFromNode(call, sourceFile), 'first argument must be a string literal or an inline { name: "..." } object (or use the object form)');
+    }
+    const dataArg = args[1];
+    if (!dataArg) {
+        return fail("referenceData", sourceLocationFromNode(call, sourceFile), "expected a data array as second argument");
+    }
+    const data = readDataLiteralNode(dataArg);
+    if (!Array.isArray(data) || !data.every(isPlainObject)) {
+        return fail("referenceData", sourceLocationFromNode(call, sourceFile), "data must be an array of plain objects");
+    }
+    let upsertKey;
+    const optionsArg = args[2];
+    if (optionsArg) {
+        const options = readDataLiteralNode(optionsArg);
+        if (!isPlainObject(options)) {
+            return fail("referenceData", sourceLocationFromNode(call, sourceFile), "options could not be read as a plain object");
+        }
+        if (options["upsertKey"] !== undefined) {
+            if (typeof options["upsertKey"] !== "string") {
+                return fail("referenceData", sourceLocationFromNode(call, sourceFile), "upsertKey must be a string when provided");
+            }
+            upsertKey = options["upsertKey"];
+        }
+    }
+    return ok({
+        kind: "referenceData",
+        source: sourceLocationFromNode(call, sourceFile),
+        entityName,
+        data: data,
+        ...(upsertKey !== undefined && { upsertKey }),
+    });
+}
+export function extractUseExtension(call, sourceFile) {
+    const args = call.getArguments();
+    const first = args[0];
+    if (!first) {
+        return fail("useExtension", sourceLocationFromNode(call, sourceFile), "expected at least one argument");
+    }
+    const obj = first.asKind(SyntaxKind.ObjectLiteralExpression);
+    if (obj && args.length === 1) {
+        const nameInit = obj
+            .getProperty("name")
+            ?.asKind(SyntaxKind.PropertyAssignment)
+            ?.getInitializer()
+            ?.asKind(SyntaxKind.StringLiteral);
+        if (!nameInit) {
+            return fail("useExtension", sourceLocationFromNode(call, sourceFile), "object form requires a string-literal `name` property");
+        }
+        const entityInit = obj
+            .getProperty("entity")
+            ?.asKind(SyntaxKind.PropertyAssignment)
+            ?.getInitializer();
+        if (!entityInit) {
+            return fail("useExtension", sourceLocationFromNode(call, sourceFile), "object form requires an `entity` property");
+        }
+        const entityName = readNameOrRef(entityInit);
+        if (!entityName) {
+            return fail("useExtension", sourceLocationFromNode(call, sourceFile), '`entity` must be a string literal or `{ name: "..." }` ref');
+        }
+        let options;
+        const optionsInit = obj
+            .getProperty("options")
+            ?.asKind(SyntaxKind.PropertyAssignment)
+            ?.getInitializer();
+        if (optionsInit) {
+            const parsed = readDataLiteralNode(optionsInit);
+            if (!isPlainObject(parsed)) {
+                return fail("useExtension", sourceLocationFromNode(call, sourceFile), "options could not be read as a plain object");
+            }
+            options = parsed;
+        }
+        return ok({
+            kind: "useExtension",
+            source: sourceLocationFromNode(call, sourceFile),
+            extensionName: nameInit.getLiteralValue(),
+            entityName,
+            ...(options !== undefined && { options }),
+        });
+    }
+    const extensionNameRef = readNameLiteralRef(first);
+    if (extensionNameRef === undefined) {
+        return fail("useExtension", sourceLocationFromNode(call, sourceFile), "first argument must be a string literal extension name, or an identifier resolving to one (or use the object form)");
+    }
+    const entityRefArg = args[1];
+    if (!entityRefArg) {
+        return fail("useExtension", sourceLocationFromNode(call, sourceFile), "expected an entity reference as second argument");
+    }
+    const entityName = readNameOrRef(entityRefArg);
+    if (!entityName) {
+        return fail("useExtension", sourceLocationFromNode(call, sourceFile), 'second argument must be a string literal or an inline { name: "..." } object');
+    }
+    const optionsArg = args[2];
+    let options;
+    if (optionsArg) {
+        const parsed = readDataLiteralNode(optionsArg);
+        if (!isPlainObject(parsed)) {
+            return fail("useExtension", sourceLocationFromNode(call, sourceFile), "options could not be read as a plain object");
+        }
+        options = parsed;
+    }
+    return ok({
+        kind: "useExtension",
+        source: sourceLocationFromNode(call, sourceFile),
+        extensionName: extensionNameRef.value,
+        ...(extensionNameRef.raw !== undefined && { extensionNameRaw: extensionNameRef.raw }),
+        entityName,
+        ...(options !== undefined && { options }),
+    });
+}

package/dist/engine/feature-ast/extractors/round5.d.ts

@@ -0,0 +1,8 @@
+import type { CallExpression, SourceFile } from "ts-morph";
+import type { EnvSchemaPattern, ExposesApiPattern, ExtendsRegistrarPattern, UsesApiPattern } from "../patterns.js";
+import { type ExtractOutput } from "./shared.js";
+export declare function extractEnvSchema(call: CallExpression, sourceFile: SourceFile): ExtractOutput<EnvSchemaPattern>;
+export declare function extractExtendsRegistrar(call: CallExpression, sourceFile: SourceFile): ExtractOutput<ExtendsRegistrarPattern>;
+export declare function extractUsesApi(call: CallExpression, sourceFile: SourceFile): ExtractOutput<UsesApiPattern>;
+export declare function extractExposesApi(call: CallExpression, sourceFile: SourceFile): ExtractOutput<ExposesApiPattern>;
+export declare function extractStoreTable(call: CallExpression, sourceFile: SourceFile): ExtractOutput<never>;

package/dist/engine/feature-ast/extractors/round5.js

@@ -0,0 +1,63 @@
+import { sourceLocationFromNode } from "../source-location.js";
+import { fail, ok, readNameLiteral, readNameLiteralRef } from "./shared.js";
+export function extractEnvSchema(call, sourceFile) {
+    const arg = call.getArguments()[0];
+    if (!arg) {
+        return fail("envSchema", sourceLocationFromNode(call, sourceFile), "expected a single Zod-object schema argument (e.g. z.object({...}))");
+    }
+    return ok({
+        kind: "envSchema",
+        source: sourceLocationFromNode(call, sourceFile),
+        schemaBody: sourceLocationFromNode(arg, sourceFile),
+    });
+}
+export function extractExtendsRegistrar(call, sourceFile) {
+    const args = call.getArguments();
+    const first = args[0];
+    const extensionNameRef = first && readNameLiteralRef(first);
+    if (!extensionNameRef) {
+        return fail("extendsRegistrar", sourceLocationFromNode(call, sourceFile), "first argument must be a string literal extension name, or an identifier resolving to one");
+    }
+    const defArg = args[1];
+    if (!defArg) {
+        return fail("extendsRegistrar", sourceLocationFromNode(call, sourceFile), "expected a definition argument");
+    }
+    return ok({
+        kind: "extendsRegistrar",
+        source: sourceLocationFromNode(call, sourceFile),
+        extensionName: extensionNameRef.value,
+        ...(extensionNameRef.raw !== undefined && { extensionNameRaw: extensionNameRef.raw }),
+        defBody: sourceLocationFromNode(defArg, sourceFile),
+    });
+}
+export function extractUsesApi(call, sourceFile) {
+    const arg = call.getArguments()[0];
+    const apiName = arg && readNameLiteral(arg);
+    if (!apiName) {
+        return fail("usesApi", sourceLocationFromNode(call, sourceFile), 'expected a single string-literal API name (e.g. "sessions.revokeAllForUser"), or an identifier resolving to one');
+    }
+    return ok({
+        kind: "usesApi",
+        source: sourceLocationFromNode(call, sourceFile),
+        apiName,
+    });
+}
+export function extractExposesApi(call, sourceFile) {
+    const arg = call.getArguments()[0];
+    const apiName = arg && readNameLiteral(arg);
+    if (!apiName) {
+        return fail("exposesApi", sourceLocationFromNode(call, sourceFile), 'expected a single string-literal API name (e.g. "sessions.revokeAllForUser"), or an identifier resolving to one');
+    }
+    return ok({
+        kind: "exposesApi",
+        source: sourceLocationFromNode(call, sourceFile),
+        apiName,
+    });
+}
+export function extractStoreTable(call, sourceFile) {
+    // The meta argument is always a factory call (defineUnmanagedTable /
+    // deriveEntityTableMeta) or a captured identifier — never an inline literal,
+    // so there is nothing to extract statically. A clean ParseError (not
+    // UnknownPattern) marks it design-time-unreadable, like entity-by-identifier.
+    return fail("storeTable", sourceLocationFromNode(call, sourceFile), "storeTable meta is a factory/identifier argument, not a static literal");
+}

package/dist/engine/feature-ast/extractors/round6.d.ts

@@ -0,0 +1,4 @@
+import type { CallExpression, SourceFile } from "ts-morph";
+import type { TreeActionsPattern } from "../patterns.js";
+import { type ExtractOutput } from "./shared.js";
+export declare function extractTreeActions(call: CallExpression, sourceFile: SourceFile): ExtractOutput<TreeActionsPattern>;

package/dist/engine/feature-ast/extractors/round6.js

@@ -0,0 +1,17 @@
+import { sourceLocationFromNode } from "../source-location.js";
+import { fail, isPlainObject, ok, readDataLiteralNode } from "./shared.js";
+export function extractTreeActions(call, sourceFile) {
+    const arg = call.getArguments()[0];
+    if (!arg) {
+        return fail("treeActions", sourceLocationFromNode(call, sourceFile), "expected an action-map object literal as first argument");
+    }
+    const definitions = readDataLiteralNode(arg);
+    if (!isPlainObject(definitions)) {
+        return fail("treeActions", sourceLocationFromNode(call, sourceFile), "action-map could not be read as a plain object");
+    }
+    return ok({
+        kind: "treeActions",
+        source: sourceLocationFromNode(call, sourceFile),
+        definitions: definitions,
+    });
+}

package/dist/engine/feature-ast/extractors/shared.d.ts

@@ -0,0 +1,85 @@
+import type { CallExpression, Node, ObjectLiteralExpression } from "ts-morph";
+import type { ParseError } from "../parse.js";
+export type ExtractOutput<TPattern> = {
+    readonly kind: "pattern";
+    readonly pattern: TPattern;
+} | {
+    readonly kind: "error";
+    readonly error: ParseError;
+};
+export declare function ok<TPattern>(pattern: TPattern): ExtractOutput<TPattern>;
+export declare function fail(methodName: string, source: ParseError["source"], reason: string): {
+    readonly kind: "error";
+    readonly error: ParseError;
+};
+export declare function readStringLiteralArgs(call: CallExpression): readonly string[] | undefined;
+export declare function readBooleanProperty(objectLiteral: Node, propertyName: string): boolean | undefined;
+/**
+ * Marks a value the parser could not resolve into a literal (an Identifier
+ * reference, a call expression, ...) while preserving its exact source text.
+ * `renderValue` re-emits `__raw` verbatim instead of re-serializing the
+ * value, so round-tripping a reference like `eventEntity` never expands it
+ * into an inlined object literal.
+ */
+export type RawRefSentinel = {
+    readonly __raw: string;
+};
+export declare function isRawRefSentinel(value: unknown): value is RawRefSentinel;
+export declare function containsRawRefSentinel(value: unknown): boolean;
+export declare function readDataLiteralNode(node: Node): unknown;
+/**
+ * A node's literal string value, or the raw-ref sentinel when it resolves to
+ * an unresolvable identifier/factory-call/member-access (see
+ * readDataLiteralNode). undefined for anything else (number, boolean, ...).
+ */
+export declare function readStringOrRaw(node: Node): string | RawRefSentinel | undefined;
+/**
+ * Like readStringLiteralArgs, but an argument that resolves to a raw-ref
+ * sentinel is kept as that sentinel instead of failing the whole call. Used
+ * where a value stands in for a single name/key and inlining its resolved
+ * string would corrupt the render roundtrip (e.g. `r.requires(someFeature.name)`
+ * — see #1009).
+ */
+export declare function readStringOrRawArgs(call: CallExpression): readonly (string | RawRefSentinel)[] | undefined;
+export { isPlainObject } from "../../../utils/is-plain-object.js";
+export declare function readPropertyKey(propAssign: import("ts-morph").PropertyAssignment): string;
+/**
+ * Resolved name plus, when the source node was an identifier rather than
+ * a string literal, the identifier's exact source text. Mirrors
+ * `RawRefSentinel`'s round-trip contract: extractors that need to re-emit
+ * the original reference (not its resolved value) keep `raw` alongside
+ * `value`; extractors that only need the string keep using
+ * `readNameLiteral`, which discards it.
+ */
+export type NameLiteralRef = {
+    readonly value: string;
+    readonly raw?: string;
+};
+/**
+ * Like `readNameLiteral`, but for callers that must preserve an
+ * identifier-authored name across a render → parse round-trip (see #2111).
+ * `raw` is populated only when the node resolved via an identifier — a
+ * string-literal node has nothing worth preserving beyond its value, and
+ * setting `raw` for it too would make `JSON.stringify(value)` and
+ * `node.getText()` diverge on quote style.
+ */
+export declare function readNameLiteralRef(node: Node): NameLiteralRef | undefined;
+/**
+ * A node's string value when it's a string literal, or when it's a bare
+ * Identifier that resolves to one via a `const X = "..."` declaration
+ * (same-file or imported) — the pattern used throughout the framework's
+ * own bundled-features for registrar-call names (`EXT_TENANT_DATA`,
+ * `TENANT_SECRET_READ_EVENT`, ...) instead of repeating string literals.
+ * undefined for anything unresolvable (factory call, member access,
+ * external/ambient identifier) — callers keep their existing ParseError
+ * fallback, no crash. Discards the original identifier text; use
+ * `readNameLiteralRef` when the caller must preserve it for rendering.
+ */
+export declare function readNameLiteral(node: Node): string | undefined;
+export declare function readNameOrRef(node: Node): string | undefined;
+/** Resolve an inline object literal or a same-file `const` that initializes to one. */
+export declare function resolveSameFileObjectLiteral(node: Node): ObjectLiteralExpression | undefined;
+export declare function readObjectPropertyInitializer(obj: ObjectLiteralExpression, propertyName: string): import("ts-morph").Expression | undefined;
+export declare function findFunctionLiteral(node: Node): Node | undefined;
+export declare function readNameOrRefOrList(node: Node): string | readonly string[] | undefined;
+export declare function readVarargsOrArrayProp(call: CallExpression, arrayPropName: "features" | "keys"): readonly (string | RawRefSentinel)[] | undefined;