@cocoar/scenar-tooling 0.1.0-beta.21

package/src/lib/generate-scenario-registry/generate-scenario-registry.fn.js

@@ -0,0 +1,699 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateScenarioRegistry = generateScenarioRegistry;
+const tslib_1 = require("tslib");
+const node_fs_1 = require("node:fs");
+const promises_1 = require("node:fs/promises");
+const node_path_1 = require("node:path");
+const tinyglobby_1 = require("tinyglobby");
+const ts_morph_1 = require("ts-morph");
+const scenar_registry_1 = require("@cocoar/scenar-registry");
+const node_1 = require("@cocoar/scenar-registry/node");
+const path_utils_1 = require("../path-utils");
+function generateScenarioRegistry(config, logger, options) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        const workspaceRoot = process.cwd();
+        const outputFilePath = (0, node_1.resolveGeneratedRegistryPath)({
+            workspaceRoot,
+            outputFilePath: options === null || options === void 0 ? void 0 : options.outputFilePath,
+        });
+        const ignoredDirNames = ['node_modules', 'dist', '.git'];
+        const scenarioFileAbsPaths = [];
+        const ignoredGlobs = ignoredDirNames.map((d) => `**/${d}/**`);
+        const matches = yield (0, tinyglobby_1.glob)(config.scenarios, {
+            cwd: workspaceRoot,
+            absolute: true,
+            onlyFiles: true,
+            dot: false,
+            ignore: ignoredGlobs,
+        });
+        for (const filePath of matches) {
+            if (!filePath.endsWith('.scenario.ts'))
+                continue;
+            scenarioFileAbsPaths.push((0, node_path_1.resolve)(filePath));
+        }
+        logger === null || logger === void 0 ? void 0 : logger.debug(`Found ${scenarioFileAbsPaths.length} *.scenario.ts files`);
+        const project = new ts_morph_1.Project({
+            tsConfigFilePath: (0, node_path_1.resolve)(workspaceRoot, '.scenar/tsconfig.scenar.json'),
+            skipAddingFilesFromTsConfig: true,
+        });
+        const issues = [];
+        const extracted = [];
+        const successfullyParsedScenarioFiles = new Set();
+        for (const absPath of scenarioFileAbsPaths) {
+            try {
+                const found = extractScenarioExports(project, absPath);
+                for (const s of found)
+                    extracted.push(s);
+                successfullyParsedScenarioFiles.add(absPath);
+            }
+            catch (err) {
+                const message = err instanceof Error ? err.message : String(err);
+                issues.push({ fileAbsPath: absPath, message });
+                logger === null || logger === void 0 ? void 0 : logger.warn(`Skipping scenario file: ${absPath}`);
+                logger === null || logger === void 0 ? void 0 : logger.debug(message);
+            }
+        }
+        extracted.sort((a, b) => a.id.localeCompare(b.id));
+        const seenIds = new Set();
+        const scenarios = [];
+        for (const s of extracted) {
+            if (seenIds.has(s.id)) {
+                issues.push({
+                    fileAbsPath: s.fileAbsPath,
+                    message: `Duplicate scenario id '${s.id}'. This file will be skipped.`,
+                });
+                logger === null || logger === void 0 ? void 0 : logger.warn(`Skipping duplicate scenario id '${s.id}' in ${s.fileAbsPath}`);
+                continue;
+            }
+            seenIds.add(s.id);
+            scenarios.push(s);
+        }
+        const scenariosWithRuntimeIndex = scenarios.map((s) => (Object.assign(Object.assign({}, s), { scenarioImportPath: (0, path_utils_1.toRelativeImport)(outputFilePath, s.fileAbsPath) })));
+        const parserBlocks = scenariosWithRuntimeIndex
+            .map((s, index) => {
+            const defaultInputEntries = s.defaultInputs
+                .map((p) => `  ${JSON.stringify(p.inputName)}: ${p.valueExpression},`)
+                .join('\n');
+            const requiredInputEntries = s.requiredInputs
+                .map((p) => `  ${JSON.stringify(p.inputName)},`)
+                .join('\n');
+            const entries = s.inputParsers
+                .map((p) => `  ${JSON.stringify(p.inputName)}: ${p.parserExpression},`)
+                .join('\n');
+            const codecDescriptorEntries = s.inputCodecDescriptors
+                .map((d) => `  ${JSON.stringify(d.inputName)}: ${d.descriptorExpression},`)
+                .join('\n');
+            const canAutoImport = !!s.componentFileAbsPath && !!s.componentExportName;
+            const componentImportPath = canAutoImport
+                ? (0, path_utils_1.toRelativeImport)(outputFilePath, s.componentFileAbsPath)
+                : null;
+            const loadComponentExpression = canAutoImport
+                ? `(async () => {\n    const mod = await import('${componentImportPath}');\n    return mod.${s.componentExportName};\n  })`
+                : `(async () => {\n    throw new Error('Scenario is missing component information. Provide component/loadComponent() in the scenario module, or defineScenario<TComponent>() with an importable component type.');\n  })`;
+            return `const autoInputs_${index}: Record<string, unknown> = {\n${defaultInputEntries}\n};\n\nconst requiredInputs_${index}: readonly string[] = [\n${requiredInputEntries}\n];\n\nconst autoInputParsers_${index}: Record<string, ScenarioInputParser> = {\n${entries}\n};\n\nconst autoInputCodecDescriptors_${index}: Record<string, ScenarioInputCodecDescriptor> = {\n${codecDescriptorEntries}\n};\n\nconst loadComponent_${index} = ${loadComponentExpression};`;
+        })
+            .join('\n\n');
+        const indexEntries = scenariosWithRuntimeIndex
+            .map((s, index) => {
+            const idLiteral = JSON.stringify(s.id);
+            const exportNameLiteral = JSON.stringify(s.exportName);
+            return `  ${idLiteral}: {\n    id: ${idLiteral},\n    exportName: ${exportNameLiteral},\n    loadScenarioModule: () => import('${s.scenarioImportPath}'),\n    autoInputs: autoInputs_${index},\n    requiredInputs: requiredInputs_${index},\n    inputParsers: autoInputParsers_${index},\n    inputCodecDescriptors: autoInputCodecDescriptors_${index},\n    loadComponent: loadComponent_${index},\n  },`;
+        })
+            .join('\n');
+        const content = `/* eslint-disable */\n/*\n * Generated by Scenar Backstage tools.\n * Do not edit by hand.\n */\n\nexport const SCENAR_REGISTRY_SCHEMA_VERSION = ${scenar_registry_1.SCENAR_REGISTRY_SCHEMA_VERSION};\n\nimport {\n  type ScenarioInputCodecDescriptor,\n  type ScenarioInputParser,\n  scenarioParseBoolean,\n  scenarioParseIsoDate,\n  scenarioParseJsonArray,\n  scenarioParseJsonObject,\n  scenarioParseNumber,\n  scenarioParseString,\n} from '@cocoar/scenar-core';\n\n${parserBlocks}\n\nexport const SCENAR_REGISTRY_INDEX = {\n${indexEntries}\n} as const;\n\nexport const SCENAR_REGISTRY_IDS = Object.keys(SCENAR_REGISTRY_INDEX).sort();\n`;
+        yield (0, promises_1.mkdir)((0, node_path_1.dirname)(outputFilePath), { recursive: true });
+        yield (0, promises_1.writeFile)(outputFilePath, content, 'utf-8');
+        const watchedFileAbsPaths = Array.from(new Set([
+            ...successfullyParsedScenarioFiles,
+            ...scenarios.flatMap((s) => [s.fileAbsPath, s.componentFileAbsPath].filter(Boolean)),
+        ].map((p) => (0, node_path_1.resolve)(p)))).sort((a, b) => a.localeCompare(b));
+        return {
+            outputFilePath,
+            scenarioCount: scenarios.length,
+            skippedScenarioFileCount: scenarioFileAbsPaths.length - successfullyParsedScenarioFiles.size,
+            issues,
+            watchedFileAbsPaths,
+        };
+    });
+}
+function extractScenarioExports(project, fileAbsPath) {
+    var _a;
+    const sourceFile = project.addSourceFileAtPath(fileAbsPath);
+    const results = [];
+    for (const statement of sourceFile.getVariableStatements()) {
+        if (!statement.isExported())
+            continue;
+        for (const decl of statement.getDeclarations()) {
+            const exportName = decl.getName();
+            const initializer = decl.getInitializer();
+            if (!initializer)
+                continue;
+            // Primary supported authoring form: export const X = defineScenario({ ... })
+            const isDefineScenarioCall = isDefineScenarioCallExpression(sourceFile, initializer);
+            if (!isDefineScenarioCall)
+                continue;
+            const objectLiteral = (_a = initializer
+                .asKindOrThrow(ts_morph_1.SyntaxKind.CallExpression)
+                .getArguments()[0]) === null || _a === void 0 ? void 0 : _a.asKind(ts_morph_1.SyntaxKind.ObjectLiteralExpression);
+            if (!objectLiteral) {
+                throw new Error(`Scenario initializer in ${fileAbsPath} must be defineScenario({ ... }).`);
+            }
+            const idProp = objectLiteral.getProperty('id');
+            if (!idProp || !idProp.isKind(ts_morph_1.SyntaxKind.PropertyAssignment)) {
+                throw new Error(`Scenario '${exportName}' in ${fileAbsPath} must define an 'id' property (string literal).`);
+            }
+            const idInitializer = idProp.getInitializer();
+            const id = (idInitializer === null || idInitializer === void 0 ? void 0 : idInitializer.isKind(ts_morph_1.SyntaxKind.StringLiteral))
+                ? idInitializer.getLiteralValue()
+                : undefined;
+            if (!id) {
+                throw new Error(`Scenario id in ${fileAbsPath} must be a string literal (e.g. id: 'demo/hello').`);
+            }
+            const componentInfo = resolveScenarioComponentInfo(sourceFile, initializer, objectLiteral, fileAbsPath);
+            const defaultInputs = componentInfo.componentFileAbsPath
+                ? extractComponentDefaultInputs(project, componentInfo.componentFileAbsPath)
+                : [];
+            const requiredInputs = componentInfo.componentFileAbsPath
+                ? extractComponentRequiredInputs(project, componentInfo.componentFileAbsPath)
+                : [];
+            const inputParsers = componentInfo.componentFileAbsPath
+                ? extractComponentInputParsers(project, componentInfo.componentFileAbsPath)
+                : [];
+            const inputCodecDescriptors = componentInfo.componentFileAbsPath
+                ? extractComponentInputCodecDescriptors(project, componentInfo.componentFileAbsPath)
+                : [];
+            results.push({
+                fileAbsPath,
+                exportName,
+                id,
+                componentFileAbsPath: componentInfo.componentFileAbsPath,
+                componentExportName: componentInfo.componentExportName,
+                defaultInputs,
+                requiredInputs,
+                inputParsers,
+                inputCodecDescriptors,
+            });
+        }
+    }
+    if (results.length === 0) {
+        throw new Error(`Expected at least one exported defineScenario(...) in ${fileAbsPath} (e.g. export const myScenario = defineScenario({ id: '...' })).`);
+    }
+    // Stable output (important when multiple scenarios exist in one file).
+    results.sort((a, b) => a.id.localeCompare(b.id));
+    return results;
+}
+function isDefineScenarioCallExpression(sourceFile, expr) {
+    var _a, _b;
+    if (!expr.isKind(ts_morph_1.SyntaxKind.CallExpression))
+        return false;
+    const call = expr.asKindOrThrow(ts_morph_1.SyntaxKind.CallExpression);
+    const callee = call.getExpression();
+    // Supports:
+    // - import { defineScenario } from '@cocoar/scenar-core'; defineScenario(...)
+    // - import { defineScenario as def } from '@cocoar/scenar-core'; def(...)
+    if (callee.isKind(ts_morph_1.SyntaxKind.Identifier)) {
+        const localName = callee.getText();
+        for (const imp of sourceFile.getImportDeclarations()) {
+            if (imp.getModuleSpecifierValue() !== '@cocoar/scenar-core')
+                continue;
+            for (const spec of imp.getNamedImports()) {
+                const importedName = spec.getName();
+                const alias = (_b = (_a = spec.getAliasNode()) === null || _a === void 0 ? void 0 : _a.getText()) !== null && _b !== void 0 ? _b : null;
+                if (importedName === 'defineScenario' &&
+                    (alias ? alias === localName : localName === 'defineScenario')) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+    // Supports:
+    // - import * as scenar from '@cocoar/scenar-core'; scenar.defineScenario(...)
+    if (callee.isKind(ts_morph_1.SyntaxKind.PropertyAccessExpression)) {
+        const pa = callee.asKindOrThrow(ts_morph_1.SyntaxKind.PropertyAccessExpression);
+        const lhs = pa.getExpression();
+        const rhs = pa.getName();
+        if (!lhs.isKind(ts_morph_1.SyntaxKind.Identifier))
+            return false;
+        if (rhs !== 'defineScenario')
+            return false;
+        const nsLocalName = lhs.getText();
+        for (const imp of sourceFile.getImportDeclarations()) {
+            if (imp.getModuleSpecifierValue() !== '@cocoar/scenar-core')
+                continue;
+            const ns = imp.getNamespaceImport();
+            if ((ns === null || ns === void 0 ? void 0 : ns.getText()) === nsLocalName)
+                return true;
+        }
+        return false;
+    }
+    return false;
+}
+function resolveScenarioComponentInfo(scenarioSourceFile, scenarioInitializer, scenarioObjectLiteral, scenarioFileAbsPath) {
+    var _a, _b, _c, _d, _e;
+    const componentProp = scenarioObjectLiteral.getProperty('component');
+    if (componentProp === null || componentProp === void 0 ? void 0 : componentProp.isKind(ts_morph_1.SyntaxKind.PropertyAssignment)) {
+        const initializer = componentProp.getInitializer();
+        if (!initializer)
+            return { componentFileAbsPath: null, componentExportName: null };
+        // Prefer symbol resolution if possible.
+        try {
+            const symbol = initializer.getType().getSymbol();
+            const decls = (_a = symbol === null || symbol === void 0 ? void 0 : symbol.getDeclarations()) !== null && _a !== void 0 ? _a : [];
+            for (const d of decls) {
+                const sf = d.getSourceFile();
+                const abs = sf.getFilePath();
+                if (!abs)
+                    continue;
+                return {
+                    componentFileAbsPath: abs,
+                    componentExportName: initializer.getText(),
+                };
+            }
+        }
+        catch (_f) {
+            // ignore
+        }
+        // Fallback: resolve from import declarations in the scenario file.
+        const name = initializer.getText();
+        for (const imp of scenarioSourceFile.getImportDeclarations()) {
+            const moduleSpec = imp.getModuleSpecifierValue();
+            if (!moduleSpec.startsWith('.'))
+                continue;
+            for (const spec of imp.getNamedImports()) {
+                const importedName = spec.getName();
+                const alias = (_c = (_b = spec.getAliasNode()) === null || _b === void 0 ? void 0 : _b.getText()) !== null && _c !== void 0 ? _c : null;
+                if (alias ? alias !== name : importedName !== name)
+                    continue;
+                const resolved = resolveModuleToTsFile(scenarioFileAbsPath, moduleSpec);
+                return {
+                    componentFileAbsPath: resolved,
+                    componentExportName: importedName,
+                };
+            }
+        }
+        return { componentFileAbsPath: null, componentExportName: name };
+    }
+    const loadComponentProp = scenarioObjectLiteral.getProperty('loadComponent');
+    if (loadComponentProp === null || loadComponentProp === void 0 ? void 0 : loadComponentProp.isKind(ts_morph_1.SyntaxKind.PropertyAssignment)) {
+        const initializer = loadComponentProp.getInitializer();
+        if (!initializer)
+            return { componentFileAbsPath: null, componentExportName: null };
+        const importCall = initializer
+            .getDescendantsOfKind(ts_morph_1.SyntaxKind.CallExpression)
+            .find((ce) => ce.getExpression().getKind() === ts_morph_1.SyntaxKind.ImportKeyword);
+        const moduleArg = importCall === null || importCall === void 0 ? void 0 : importCall.getArguments()[0];
+        if (!moduleArg || !moduleArg.isKind(ts_morph_1.SyntaxKind.StringLiteral)) {
+            return { componentFileAbsPath: null, componentExportName: null };
+        }
+        const moduleSpec = moduleArg.getLiteralValue();
+        return {
+            componentFileAbsPath: resolveModuleToTsFile(scenarioFileAbsPath, moduleSpec),
+            componentExportName: null,
+        };
+    }
+    // Fallback: defineScenario<TComponent>({ id: '...' })
+    if (scenarioInitializer.isKind(ts_morph_1.SyntaxKind.CallExpression)) {
+        const call = scenarioInitializer.asKindOrThrow(ts_morph_1.SyntaxKind.CallExpression);
+        const typeArg = (_d = call.getTypeArguments()) === null || _d === void 0 ? void 0 : _d[0];
+        if (typeArg) {
+            const type = typeArg.getType();
+            const symbol = type.getSymbol();
+            const decls = (_e = symbol === null || symbol === void 0 ? void 0 : symbol.getDeclarations()) !== null && _e !== void 0 ? _e : [];
+            for (const d of decls) {
+                const sf = d.getSourceFile();
+                const abs = sf.getFilePath();
+                if (!abs)
+                    continue;
+                return {
+                    componentFileAbsPath: abs,
+                    componentExportName: typeArg.getText(),
+                };
+            }
+        }
+    }
+    return { componentFileAbsPath: null, componentExportName: null };
+}
+function resolveModuleToTsFile(fromFileAbsPath, moduleSpecifier) {
+    if (!moduleSpecifier.startsWith('.')) {
+        return null;
+    }
+    const fromDir = (0, node_path_1.dirname)(fromFileAbsPath);
+    const base = (0, node_path_1.resolve)(fromDir, moduleSpecifier);
+    // Most Angular code imports without extension.
+    const candidates = [
+        base,
+        `${base}.ts`,
+        `${base}.tsx`,
+        (0, node_path_1.resolve)(base, 'index.ts'),
+    ];
+    for (const c of candidates) {
+        try {
+            const stat = (0, node_fs_1.statSync)(c);
+            if (stat.isFile())
+                return c;
+        }
+        catch (_a) {
+            // ignore
+        }
+    }
+    return null;
+}
+function extractComponentInputParsers(project, componentFileAbsPath) {
+    const sourceFile = project.addSourceFileAtPath(componentFileAbsPath);
+    const parsers = [];
+    for (const cls of sourceFile.getClasses()) {
+        for (const prop of cls.getProperties()) {
+            if (!isSignalInputProperty(prop))
+                continue;
+            const inputName = prop.getName();
+            if (!inputName)
+                continue;
+            const parserExpression = inferParserExpression(prop);
+            parsers.push({ inputName, parserExpression });
+        }
+    }
+    // Stable output.
+    parsers.sort((a, b) => a.inputName.localeCompare(b.inputName));
+    return parsers;
+}
+function extractComponentInputCodecDescriptors(project, componentFileAbsPath) {
+    const sourceFile = project.addSourceFileAtPath(componentFileAbsPath);
+    const descriptors = [];
+    for (const cls of sourceFile.getClasses()) {
+        for (const prop of cls.getProperties()) {
+            if (!isSignalInputProperty(prop))
+                continue;
+            const inputName = prop.getName();
+            if (!inputName)
+                continue;
+            const descriptorExpression = inferCodecDescriptorExpression(prop);
+            descriptors.push({ inputName, descriptorExpression });
+        }
+    }
+    // Stable output.
+    descriptors.sort((a, b) => a.inputName.localeCompare(b.inputName));
+    return descriptors;
+}
+function extractComponentDefaultInputs(project, componentFileAbsPath) {
+    const sourceFile = project.addSourceFileAtPath(componentFileAbsPath);
+    const defaults = [];
+    for (const cls of sourceFile.getClasses()) {
+        for (const prop of cls.getProperties()) {
+            if (!isSignalInputProperty(prop))
+                continue;
+            const inputName = prop.getName();
+            if (!inputName)
+                continue;
+            // Signal input: name = input('x')
+            const signalDefault = extractDefaultFromSignalInputInitializer(prop.getInitializer());
+            if (signalDefault !== null) {
+                defaults.push({ inputName, valueExpression: signalDefault });
+                continue;
+            }
+        }
+    }
+    defaults.sort((a, b) => a.inputName.localeCompare(b.inputName));
+    return defaults;
+}
+function extractComponentRequiredInputs(project, componentFileAbsPath) {
+    const sourceFile = project.addSourceFileAtPath(componentFileAbsPath);
+    const requiredInputs = [];
+    for (const cls of sourceFile.getClasses()) {
+        for (const prop of cls.getProperties()) {
+            if (!isRequiredSignalInputOrModelProperty(prop))
+                continue;
+            const inputName = prop.getName();
+            if (!inputName)
+                continue;
+            requiredInputs.push({ inputName });
+        }
+    }
+    requiredInputs.sort((a, b) => a.inputName.localeCompare(b.inputName));
+    return requiredInputs;
+}
+function extractDefaultFromSignalInputInitializer(initializer) {
+    if (!(initializer === null || initializer === void 0 ? void 0 : initializer.isKind(ts_morph_1.SyntaxKind.CallExpression)))
+        return null;
+    const call = initializer.asKindOrThrow(ts_morph_1.SyntaxKind.CallExpression);
+    // input.required() / model.required() have no default.
+    const exprText = call.getExpression().getText();
+    if (exprText !== 'input' && exprText !== 'model')
+        return null;
+    const firstArg = call.getArguments()[0];
+    if (!firstArg)
+        return null;
+    const expr = unwrapTrivialExpression(firstArg);
+    if (!isSafeLiteralExpression(expr))
+        return null;
+    return expr.getText();
+}
+function unwrapTrivialExpression(expr) {
+    let current = expr;
+    while (true) {
+        const paren = current.asKind(ts_morph_1.SyntaxKind.ParenthesizedExpression);
+        if (paren) {
+            current = paren.getExpression();
+            continue;
+        }
+        const asExpr = current.asKind(ts_morph_1.SyntaxKind.AsExpression);
+        if (asExpr) {
+            current = asExpr.getExpression();
+            continue;
+        }
+        const typeAssert = current.asKind(ts_morph_1.SyntaxKind.TypeAssertionExpression);
+        if (typeAssert) {
+            current = typeAssert.getExpression();
+            continue;
+        }
+        return current;
+    }
+}
+function isSafeLiteralExpression(expr) {
+    const unwrapped = unwrapTrivialExpression(expr);
+    if (unwrapped.isKind(ts_morph_1.SyntaxKind.StringLiteral) ||
+        unwrapped.isKind(ts_morph_1.SyntaxKind.NoSubstitutionTemplateLiteral) ||
+        unwrapped.isKind(ts_morph_1.SyntaxKind.NumericLiteral) ||
+        unwrapped.isKind(ts_morph_1.SyntaxKind.TrueKeyword) ||
+        unwrapped.isKind(ts_morph_1.SyntaxKind.FalseKeyword) ||
+        unwrapped.isKind(ts_morph_1.SyntaxKind.NullKeyword)) {
+        return true;
+    }
+    if (unwrapped.isKind(ts_morph_1.SyntaxKind.PrefixUnaryExpression)) {
+        const p = unwrapped.asKindOrThrow(ts_morph_1.SyntaxKind.PrefixUnaryExpression);
+        const op = p.getOperatorToken();
+        const operand = p.getOperand();
+        return (op === ts_morph_1.SyntaxKind.MinusToken && operand.isKind(ts_morph_1.SyntaxKind.NumericLiteral));
+    }
+    if (unwrapped.isKind(ts_morph_1.SyntaxKind.ArrayLiteralExpression)) {
+        const arr = unwrapped.asKindOrThrow(ts_morph_1.SyntaxKind.ArrayLiteralExpression);
+        for (const el of arr.getElements()) {
+            // Disallow spreads/holes since they are not safe literals.
+            if (el.isKind(ts_morph_1.SyntaxKind.SpreadElement) ||
+                el.isKind(ts_morph_1.SyntaxKind.OmittedExpression)) {
+                return false;
+            }
+            const elementExpression = el;
+            if (!isSafeLiteralExpression(elementExpression))
+                return false;
+        }
+        return true;
+    }
+    if (unwrapped.isKind(ts_morph_1.SyntaxKind.ObjectLiteralExpression)) {
+        const obj = unwrapped.asKindOrThrow(ts_morph_1.SyntaxKind.ObjectLiteralExpression);
+        for (const prop of obj.getProperties()) {
+            if (prop.isKind(ts_morph_1.SyntaxKind.PropertyAssignment)) {
+                const init = prop.getInitializer();
+                if (!init)
+                    return false;
+                if (!isSafeLiteralExpression(init))
+                    return false;
+                continue;
+            }
+            return false;
+        }
+        return true;
+    }
+    return false;
+}
+function inferParserExpression(prop) {
+    var _a;
+    const initializer = prop.getInitializer();
+    // If using Angular's input<T>() / input.required<T>() / model<T>() / model.required<T>(),
+    // prefer the generic argument type.
+    if ((initializer === null || initializer === void 0 ? void 0 : initializer.isKind(ts_morph_1.SyntaxKind.CallExpression)) &&
+        isSignalInputOrModelCallExpressionText(initializer.getExpression().getText())) {
+        const typeArg = (_a = initializer.getTypeArguments()) === null || _a === void 0 ? void 0 : _a[0];
+        if (typeArg) {
+            return inferParserExpressionFromTypeText(typeArg.getText());
+        }
+    }
+    let type = prop.getType();
+    type = unwrapNullableUnionType(type);
+    if (type.isBoolean())
+        return '(raw: string) => scenarioParseBoolean(raw)';
+    if (type.isNumber())
+        return '(raw: string) => scenarioParseNumber(raw)';
+    if (type.isString())
+        return '(raw: string) => scenarioParseString(raw)';
+    // Common class type: Date
+    // Canonical wire format: ISO 8601 via Date.toISOString()
+    if (type.getText() === 'Date')
+        return '(raw: string) => scenarioParseIsoDate(raw)';
+    // Structured values are transported as JSON in a single query param.
+    if (isArrayLikeType(type)) {
+        const element = getArrayLikeElementType(type);
+        if (element && isNonDateClassType(element)) {
+            return '(raw: string) => scenarioParseString(raw)';
+        }
+        return '(raw: string) => scenarioParseJsonArray(raw)';
+    }
+    if (type.isObject() && type.getText() !== 'Date') {
+        // Avoid pretending we can rebuild class instances from query params.
+        if (isNonDateClassType(type)) {
+            return '(raw: string) => scenarioParseString(raw)';
+        }
+        return '(raw: string) => scenarioParseJsonObject(raw)';
+    }
+    // Minimal fallback: keep it as a string.
+    return '(raw: string) => scenarioParseString(raw)';
+}
+function inferCodecDescriptorExpression(prop) {
+    var _a;
+    const initializer = prop.getInitializer();
+    // If using Angular's input<T>() / input.required<T>() / model<T>() / model.required<T>(),
+    // prefer the generic argument type.
+    if ((initializer === null || initializer === void 0 ? void 0 : initializer.isKind(ts_morph_1.SyntaxKind.CallExpression)) &&
+        isSignalInputOrModelCallExpressionText(initializer.getExpression().getText())) {
+        const typeArg = (_a = initializer.getTypeArguments()) === null || _a === void 0 ? void 0 : _a[0];
+        if (typeArg) {
+            return inferCodecDescriptorExpressionFromTypeText(typeArg.getText());
+        }
+    }
+    let type = prop.getType();
+    type = unwrapNullableUnionType(type);
+    if (type.isBoolean())
+        return "{ kind: 'boolean' }";
+    if (type.isNumber())
+        return "{ kind: 'number' }";
+    if (type.isString())
+        return "{ kind: 'string' }";
+    // Common class type: Date
+    if (type.getText() === 'Date')
+        return "{ kind: 'isoDate' }";
+    if (isArrayLikeType(type)) {
+        const element = getArrayLikeElementType(type);
+        if (element && isNonDateClassType(element))
+            return "{ kind: 'string' }";
+        return "{ kind: 'jsonArray' }";
+    }
+    if (type.isObject() && type.getText() !== 'Date') {
+        if (isNonDateClassType(type))
+            return "{ kind: 'string' }";
+        return "{ kind: 'jsonObject' }";
+    }
+    return "{ kind: 'string' }";
+}
+function inferParserExpressionFromTypeText(typeText) {
+    const normalized = stripNullableTypeText(typeText);
+    if (normalized === 'boolean')
+        return '(raw: string) => scenarioParseBoolean(raw)';
+    if (normalized === 'number')
+        return '(raw: string) => scenarioParseNumber(raw)';
+    if (normalized === 'string')
+        return '(raw: string) => scenarioParseString(raw)';
+    if (normalized === 'Date')
+        return '(raw: string) => scenarioParseIsoDate(raw)';
+    if (normalized.endsWith('[]') ||
+        normalized.startsWith('Array<') ||
+        normalized.startsWith('ReadonlyArray<') ||
+        normalized.startsWith('readonly ')) {
+        return '(raw: string) => scenarioParseJsonArray(raw)';
+    }
+    if (normalized === 'object' ||
+        normalized.startsWith('Record<') ||
+        normalized.startsWith('{')) {
+        return '(raw: string) => scenarioParseJsonObject(raw)';
+    }
+    return '(raw: string) => scenarioParseString(raw)';
+}
+function inferCodecDescriptorExpressionFromTypeText(typeText) {
+    const normalized = stripNullableTypeText(typeText);
+    if (normalized === 'boolean')
+        return "{ kind: 'boolean' }";
+    if (normalized === 'number')
+        return "{ kind: 'number' }";
+    if (normalized === 'string')
+        return "{ kind: 'string' }";
+    if (normalized === 'Date')
+        return "{ kind: 'isoDate' }";
+    if (normalized.endsWith('[]') ||
+        normalized.startsWith('Array<') ||
+        normalized.startsWith('ReadonlyArray<') ||
+        normalized.startsWith('readonly ')) {
+        return "{ kind: 'jsonArray' }";
+    }
+    if (normalized === 'object' ||
+        normalized.startsWith('Record<') ||
+        normalized.startsWith('{')) {
+        return "{ kind: 'jsonObject' }";
+    }
+    return "{ kind: 'string' }";
+}
+function unwrapNullableUnionType(type) {
+    if (!type.isUnion())
+        return type;
+    const parts = type.getUnionTypes();
+    const nonNullable = parts.filter((t) => !t.isNull() && !t.isUndefined());
+    if (nonNullable.length === 1)
+        return nonNullable[0];
+    // Old enum inference became a plain string under the fixed codec set.
+    const stringLiterals = nonNullable
+        .map((t) => t.getLiteralValue())
+        .filter((v) => typeof v === 'string');
+    if (stringLiterals.length === nonNullable.length &&
+        stringLiterals.length > 0) {
+        return nonNullable[0];
+    }
+    return type;
+}
+function stripNullableTypeText(typeText) {
+    // Lightweight normalization for input<T>() / model<T>() generic arguments.
+    return typeText
+        .replace(/\s+/g, ' ')
+        .replace(/\s*\|\s*null\b/g, '')
+        .replace(/\s*\|\s*undefined\b/g, '')
+        .trim();
+}
+function isArrayLikeType(type) {
+    var _a, _b;
+    const anyType = type;
+    if (((_a = anyType.isArray) === null || _a === void 0 ? void 0 : _a.call(anyType)) === true)
+        return true;
+    if (((_b = anyType.isTuple) === null || _b === void 0 ? void 0 : _b.call(anyType)) === true)
+        return true;
+    const text = type.getText();
+    return (text.endsWith('[]') ||
+        text.startsWith('Array<') ||
+        text.startsWith('ReadonlyArray<') ||
+        text.startsWith('readonly '));
+}
+function getArrayLikeElementType(type) {
+    var _a;
+    const anyType = type;
+    const el = (_a = anyType.getArrayElementType) === null || _a === void 0 ? void 0 : _a.call(anyType);
+    return el !== null && el !== void 0 ? el : null;
+}
+function isNonDateClassType(type) {
+    if (type.getText() === 'Date')
+        return false;
+    const symbol = type.getSymbol();
+    if (!symbol)
+        return false;
+    return symbol
+        .getDeclarations()
+        .some((d) => d.getKind() === ts_morph_1.SyntaxKind.ClassDeclaration);
+}
+function isSignalInputOrModelCallExpressionText(exprText) {
+    return (exprText === 'input' ||
+        exprText === 'input.required' ||
+        exprText === 'model' ||
+        exprText === 'model.required');
+}
+function isSignalInputProperty(prop) {
+    const initializer = prop.getInitializer();
+    if (!(initializer === null || initializer === void 0 ? void 0 : initializer.isKind(ts_morph_1.SyntaxKind.CallExpression)))
+        return false;
+    const call = initializer.asKindOrThrow(ts_morph_1.SyntaxKind.CallExpression);
+    return isSignalInputOrModelCallExpressionText(call.getExpression().getText());
+}
+function isRequiredSignalInputOrModelProperty(prop) {
+    const initializer = prop.getInitializer();
+    if (!(initializer === null || initializer === void 0 ? void 0 : initializer.isKind(ts_morph_1.SyntaxKind.CallExpression)))
+        return false;
+    const call = initializer.asKindOrThrow(ts_morph_1.SyntaxKind.CallExpression);
+    const exprText = call.getExpression().getText();
+    return exprText === 'input.required' || exprText === 'model.required';
+}
+//# sourceMappingURL=generate-scenario-registry.fn.js.map