@ng-prism/core 21.0.0

package/dist/builder/plugin-runner/plugin-runner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin-runner.d.ts","sourceRoot":"","sources":["../../../src/builder/plugin-runner/plugin-runner.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,aAAa,EAAoB,MAAM,8BAA8B,CAAC;AAGnG,wBAAsB,cAAc,CAClC,QAAQ,EAAE,aAAa,EACvB,OAAO,EAAE,aAAa,EAAE,GACvB,OAAO,CAAC,aAAa,CAAC,CA2CxB"}

package/dist/builder/plugin-runner/plugin-runner.js

@@ -0,0 +1,38 @@
+export async function runPluginHooks(manifest, plugins) {
+    let components = [...manifest.components];
+    for (const comp of components) {
+        let current = comp;
+        for (const plugin of plugins) {
+            if (plugin.onComponentScanned) {
+                const result = await plugin.onComponentScanned(current);
+                if (result) {
+                    current = result;
+                }
+            }
+        }
+        components[components.indexOf(comp)] = current;
+    }
+    let pages = [...(manifest.pages ?? [])];
+    for (let i = 0; i < pages.length; i++) {
+        let current = pages[i];
+        for (const plugin of plugins) {
+            if (plugin.onPageScanned) {
+                const result = await plugin.onPageScanned(current);
+                if (result) {
+                    current = result;
+                }
+            }
+        }
+        pages[i] = current;
+    }
+    let result = { components, pages };
+    for (const plugin of plugins) {
+        if (plugin.onManifestReady) {
+            const updated = await plugin.onManifestReady(result);
+            if (updated) {
+                result = updated;
+            }
+        }
+    }
+    return result;
+}

package/dist/builder/scanner/ast-utils.d.ts

@@ -0,0 +1,20 @@
+import ts from 'typescript';
+/**
+ * Statically evaluate an AST expression node.
+ * Returns `undefined` for non-evaluable expressions (variables, function calls, spread).
+ */
+export declare function evaluateExpression(node: ts.Expression): unknown;
+/**
+ * Find a decorator by name on a class or property declaration.
+ */
+export declare function findDecorator(node: ts.ClassDeclaration | ts.PropertyDeclaration, name: string): ts.Decorator | undefined;
+/**
+ * Extract the first argument of a decorator call expression.
+ * Returns undefined if the decorator is not a call or has no arguments.
+ */
+export declare function getDecoratorArgument(decorator: ts.Decorator): ts.Expression | undefined;
+/**
+ * Get the JSDoc comment for a node.
+ */
+export declare function getJsDocComment(node: ts.Node, checker: ts.TypeChecker): string | undefined;
+//# sourceMappingURL=ast-utils.d.ts.map

package/dist/builder/scanner/ast-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ast-utils.d.ts","sourceRoot":"","sources":["../../../src/builder/scanner/ast-utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,YAAY,CAAC;AAE5B;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,EAAE,CAAC,UAAU,GAAG,OAAO,CAoD/D;AAED;;GAEG;AACH,wBAAgB,aAAa,CAC3B,IAAI,EAAE,EAAE,CAAC,gBAAgB,GAAG,EAAE,CAAC,mBAAmB,EAClD,IAAI,EAAE,MAAM,GACX,EAAE,CAAC,SAAS,GAAG,SAAS,CAc1B;AAED;;;GAGG;AACH,wBAAgB,oBAAoB,CAAC,SAAS,EAAE,EAAE,CAAC,SAAS,GAAG,EAAE,CAAC,UAAU,GAAG,SAAS,CAMvF;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,EAAE,OAAO,EAAE,EAAE,CAAC,WAAW,GAAG,MAAM,GAAG,SAAS,CAU1F"}

package/dist/builder/scanner/ast-utils.js

@@ -0,0 +1,100 @@
+import ts from 'typescript';
+/**
+ * Statically evaluate an AST expression node.
+ * Returns `undefined` for non-evaluable expressions (variables, function calls, spread).
+ */
+export function evaluateExpression(node) {
+    if (ts.isStringLiteral(node) || ts.isNoSubstitutionTemplateLiteral(node)) {
+        return node.text;
+    }
+    if (ts.isNumericLiteral(node)) {
+        return Number(node.text);
+    }
+    if (node.kind === ts.SyntaxKind.TrueKeyword)
+        return true;
+    if (node.kind === ts.SyntaxKind.FalseKeyword)
+        return false;
+    if (node.kind === ts.SyntaxKind.NullKeyword)
+        return null;
+    if (node.kind === ts.SyntaxKind.UndefinedKeyword)
+        return undefined;
+    if (ts.isParenthesizedExpression(node)) {
+        return evaluateExpression(node.expression);
+    }
+    if (ts.isPrefixUnaryExpression(node) && node.operator === ts.SyntaxKind.MinusToken) {
+        const operand = evaluateExpression(node.operand);
+        if (typeof operand === 'number')
+            return -operand;
+        return undefined;
+    }
+    if (ts.isArrayLiteralExpression(node)) {
+        const result = [];
+        for (const element of node.elements) {
+            if (ts.isSpreadElement(element))
+                return undefined;
+            result.push(evaluateExpression(element));
+        }
+        return result;
+    }
+    if (ts.isObjectLiteralExpression(node)) {
+        const result = {};
+        for (const prop of node.properties) {
+            if (ts.isSpreadAssignment(prop))
+                return undefined;
+            if (!ts.isPropertyAssignment(prop))
+                return undefined;
+            const key = ts.isIdentifier(prop.name)
+                ? prop.name.text
+                : ts.isStringLiteral(prop.name)
+                    ? prop.name.text
+                    : undefined;
+            if (key === undefined)
+                return undefined;
+            result[key] = evaluateExpression(prop.initializer);
+        }
+        return result;
+    }
+    return undefined;
+}
+/**
+ * Find a decorator by name on a class or property declaration.
+ */
+export function findDecorator(node, name) {
+    const decorators = ts.getDecorators(node);
+    if (!decorators)
+        return undefined;
+    return decorators.find((d) => {
+        const expr = d.expression;
+        // @Name
+        if (ts.isIdentifier(expr))
+            return expr.text === name;
+        // @Name(...)
+        if (ts.isCallExpression(expr) && ts.isIdentifier(expr.expression)) {
+            return expr.expression.text === name;
+        }
+        return false;
+    });
+}
+/**
+ * Extract the first argument of a decorator call expression.
+ * Returns undefined if the decorator is not a call or has no arguments.
+ */
+export function getDecoratorArgument(decorator) {
+    const expr = decorator.expression;
+    if (ts.isCallExpression(expr) && expr.arguments.length > 0) {
+        return expr.arguments[0];
+    }
+    return undefined;
+}
+/**
+ * Get the JSDoc comment for a node.
+ */
+export function getJsDocComment(node, checker) {
+    const symbol = checker.getSymbolAtLocation(ts.isClassDeclaration(node) || ts.isPropertyDeclaration(node)
+        ? (node.name ?? node)
+        : node);
+    if (!symbol)
+        return undefined;
+    const doc = ts.displayPartsToString(symbol.getDocumentationComment(checker)).trim();
+    return doc || undefined;
+}

package/dist/builder/scanner/component.scanner.d.ts

@@ -0,0 +1,7 @@
+import ts from 'typescript';
+import type { ScannedComponent } from '../../plugin/plugin.types.js';
+/**
+ * Scan exported symbols for Angular components annotated with @Showcase.
+ */
+export declare function scanComponents(exports: ts.Symbol[], checker: ts.TypeChecker): ScannedComponent[];
+//# sourceMappingURL=component.scanner.d.ts.map

package/dist/builder/scanner/component.scanner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"component.scanner.d.ts","sourceRoot":"","sources":["../../../src/builder/scanner/component.scanner.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,YAAY,CAAC;AAC5B,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,8BAA8B,CAAC;AAKrE;;GAEG;AACH,wBAAgB,cAAc,CAC5B,OAAO,EAAE,EAAE,CAAC,MAAM,EAAE,EACpB,OAAO,EAAE,EAAE,CAAC,WAAW,GACtB,gBAAgB,EAAE,CA0CpB"}

package/dist/builder/scanner/component.scanner.js

@@ -0,0 +1,113 @@
+import ts from 'typescript';
+import { evaluateExpression, findDecorator, getDecoratorArgument } from './ast-utils.js';
+import { extractInputs, extractOutputs } from './input.extractor.js';
+/**
+ * Scan exported symbols for Angular components annotated with @Showcase.
+ */
+export function scanComponents(exports, checker) {
+    const components = [];
+    for (const sym of exports) {
+        const resolved = sym.flags & ts.SymbolFlags.Alias
+            ? checker.getAliasedSymbol(sym)
+            : sym;
+        const classDecl = resolved.declarations?.find(ts.isClassDeclaration);
+        if (!classDecl)
+            continue;
+        const showcaseDecorator = findDecorator(classDecl, 'Showcase');
+        if (!showcaseDecorator)
+            continue;
+        const showcaseConfig = extractShowcaseConfig(showcaseDecorator);
+        if (!showcaseConfig)
+            continue;
+        const componentMeta = extractComponentMeta(classDecl);
+        const inputs = extractInputs(classDecl, checker);
+        const outputs = extractOutputs(classDecl, checker);
+        const filePath = classDecl.getSourceFile().fileName;
+        const className = classDecl.name?.text ?? 'Anonymous';
+        if (hasDecoratorInputs(classDecl)) {
+            console.warn(`⚠ ng-prism: ${className} uses @Input() decorators which are not fully supported. ` +
+                `Migrate to input() signals for full ng-prism support.`);
+        }
+        components.push({
+            className,
+            filePath,
+            showcaseConfig,
+            inputs,
+            outputs,
+            componentMeta,
+        });
+    }
+    return components;
+}
+function hasDecoratorInputs(classDecl) {
+    for (const member of classDecl.members) {
+        if (!ts.isPropertyDeclaration(member))
+            continue;
+        if (findDecorator(member, 'Input'))
+            return true;
+    }
+    return false;
+}
+function extractShowcaseConfig(decorator) {
+    const arg = getDecoratorArgument(decorator);
+    if (!arg)
+        return undefined;
+    const raw = evaluateExpression(arg);
+    if (!raw || typeof raw !== 'object' || !('title' in raw))
+        return undefined;
+    const obj = raw;
+    const config = {
+        title: obj['title'],
+    };
+    if (obj['description'])
+        config.description = obj['description'];
+    if (obj['category'])
+        config.category = obj['category'];
+    if (obj['tags'])
+        config.tags = obj['tags'];
+    if (obj['meta'])
+        config.meta = obj['meta'];
+    if (obj['host'] !== undefined)
+        config.host = obj['host'];
+    if (obj['renderPage'])
+        config.renderPage = obj['renderPage'];
+    if (Array.isArray(obj['variants'])) {
+        config.variants = obj['variants'];
+    }
+    return config;
+}
+function extractComponentMeta(classDecl) {
+    const componentDecorator = findDecorator(classDecl, 'Component');
+    if (componentDecorator) {
+        const arg = getDecoratorArgument(componentDecorator);
+        if (!arg)
+            return { selector: '', standalone: true, isDirective: false };
+        const raw = evaluateExpression(arg);
+        if (!raw || typeof raw !== 'object') {
+            return { selector: '', standalone: true, isDirective: false };
+        }
+        const obj = raw;
+        return {
+            selector: obj['selector'] ?? '',
+            standalone: obj['standalone'] !== false,
+            isDirective: false,
+        };
+    }
+    const directiveDecorator = findDecorator(classDecl, 'Directive');
+    if (directiveDecorator) {
+        const arg = getDecoratorArgument(directiveDecorator);
+        if (!arg)
+            return { selector: '', standalone: true, isDirective: true };
+        const raw = evaluateExpression(arg);
+        if (!raw || typeof raw !== 'object') {
+            return { selector: '', standalone: true, isDirective: true };
+        }
+        const obj = raw;
+        return {
+            selector: obj['selector'] ?? '',
+            standalone: obj['standalone'] !== false,
+            isDirective: true,
+        };
+    }
+    return { selector: '', standalone: true, isDirective: false };
+}

package/dist/builder/scanner/entry-point-discovery.d.ts

@@ -0,0 +1,6 @@
+export interface DiscoveredEntryPoint {
+    entryFile: string;
+    importPath: string;
+}
+export declare function discoverSecondaryEntryPoints(libraryRoot: string, baseImportPath: string): DiscoveredEntryPoint[];
+//# sourceMappingURL=entry-point-discovery.d.ts.map

package/dist/builder/scanner/entry-point-discovery.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"entry-point-discovery.d.ts","sourceRoot":"","sources":["../../../src/builder/scanner/entry-point-discovery.ts"],"names":[],"mappings":"AAGA,MAAM,WAAW,oBAAoB;IACnC,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,wBAAgB,4BAA4B,CAC1C,WAAW,EAAE,MAAM,EACnB,cAAc,EAAE,MAAM,GACrB,oBAAoB,EAAE,CAIxB"}

package/dist/builder/scanner/entry-point-discovery.js

@@ -0,0 +1,38 @@
+import { readdirSync, readFileSync, statSync, existsSync } from 'fs';
+import { join, relative, posix } from 'path';
+export function discoverSecondaryEntryPoints(libraryRoot, baseImportPath) {
+    const entryPoints = [];
+    findNgPackageJsons(libraryRoot, libraryRoot, baseImportPath, entryPoints);
+    return entryPoints;
+}
+function findNgPackageJsons(dir, libraryRoot, baseImportPath, result) {
+    let entries;
+    try {
+        entries = readdirSync(dir);
+    }
+    catch {
+        return;
+    }
+    for (const entry of entries) {
+        if (entry === 'node_modules' || entry === '.git')
+            continue;
+        const fullPath = join(dir, entry);
+        if (!statSync(fullPath).isDirectory())
+            continue;
+        const ngPackagePath = join(fullPath, 'ng-package.json');
+        if (!existsSync(ngPackagePath)) {
+            findNgPackageJsons(fullPath, libraryRoot, baseImportPath, result);
+            continue;
+        }
+        const ngPackage = JSON.parse(readFileSync(ngPackagePath, 'utf-8'));
+        if (ngPackage.dest)
+            continue;
+        const entryFile = ngPackage.lib?.entryFile ?? 'public-api.ts';
+        const entryFilePath = join(fullPath, entryFile);
+        if (!existsSync(entryFilePath))
+            continue;
+        const relDir = relative(libraryRoot, fullPath);
+        const importPath = posix.join(baseImportPath, relDir.split('\\').join('/'));
+        result.push({ entryFile: entryFilePath, importPath });
+    }
+}

package/dist/builder/scanner/entry-point.scanner.d.ts

@@ -0,0 +1,11 @@
+import ts from 'typescript';
+export interface EntryPointResult {
+    program: ts.Program;
+    exports: ts.Symbol[];
+}
+/**
+ * Resolve all exported symbols from an entry-point file (e.g. public-api.ts).
+ * Re-exports (`export * from '...'`) are resolved automatically by TypeScript.
+ */
+export declare function resolveEntryPointExports(entryPointPath: string, compilerOptions: ts.CompilerOptions, previousProgram?: ts.Program): EntryPointResult;
+//# sourceMappingURL=entry-point.scanner.d.ts.map

package/dist/builder/scanner/entry-point.scanner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"entry-point.scanner.d.ts","sourceRoot":"","sources":["../../../src/builder/scanner/entry-point.scanner.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,YAAY,CAAC;AAE5B,MAAM,WAAW,gBAAgB;IAC/B,OAAO,EAAE,EAAE,CAAC,OAAO,CAAC;IACpB,OAAO,EAAE,EAAE,CAAC,MAAM,EAAE,CAAC;CACtB;AAED;;;GAGG;AACH,wBAAgB,wBAAwB,CACtC,cAAc,EAAE,MAAM,EACtB,eAAe,EAAE,EAAE,CAAC,eAAe,EACnC,eAAe,CAAC,EAAE,EAAE,CAAC,OAAO,GAC3B,gBAAgB,CAqBlB"}

package/dist/builder/scanner/entry-point.scanner.js

@@ -0,0 +1,19 @@
+import ts from 'typescript';
+/**
+ * Resolve all exported symbols from an entry-point file (e.g. public-api.ts).
+ * Re-exports (`export * from '...'`) are resolved automatically by TypeScript.
+ */
+export function resolveEntryPointExports(entryPointPath, compilerOptions, previousProgram) {
+    const program = ts.createProgram([entryPointPath], compilerOptions, undefined, previousProgram);
+    const checker = program.getTypeChecker();
+    const sourceFile = program.getSourceFile(entryPointPath);
+    if (!sourceFile) {
+        throw new Error(`Could not find source file: ${entryPointPath}`);
+    }
+    const moduleSymbol = checker.getSymbolAtLocation(sourceFile);
+    if (!moduleSymbol) {
+        return { program, exports: [] };
+    }
+    const exports = checker.getExportsOfModule(moduleSymbol);
+    return { program, exports };
+}

package/dist/builder/scanner/index.d.ts

@@ -0,0 +1,8 @@
+export { createScanner } from './scanner.js';
+export type { CreateScannerOptions, Scanner } from './scanner.js';
+export { resolveEntryPointExports } from './entry-point.scanner.js';
+export type { EntryPointResult } from './entry-point.scanner.js';
+export { scanComponents } from './component.scanner.js';
+export { extractInputs, extractOutputs } from './input.extractor.js';
+export { generateManifest } from './manifest.generator.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/builder/scanner/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/builder/scanner/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAC7C,YAAY,EAAE,oBAAoB,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAClE,OAAO,EAAE,wBAAwB,EAAE,MAAM,0BAA0B,CAAC;AACpE,YAAY,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AACjE,OAAO,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AACxD,OAAO,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AACrE,OAAO,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC"}

package/dist/builder/scanner/index.js

@@ -0,0 +1,6 @@
+// Scanner API exports
+export { createScanner } from './scanner.js';
+export { resolveEntryPointExports } from './entry-point.scanner.js';
+export { scanComponents } from './component.scanner.js';
+export { extractInputs, extractOutputs } from './input.extractor.js';
+export { generateManifest } from './manifest.generator.js';

package/dist/builder/scanner/input.extractor.d.ts

@@ -0,0 +1,11 @@
+import ts from 'typescript';
+import type { InputMeta, OutputMeta } from '../../plugin/plugin.types.js';
+/**
+ * Extract all @Input(), input() and model() signal metadata from a class declaration.
+ */
+export declare function extractInputs(classDecl: ts.ClassDeclaration, checker: ts.TypeChecker): InputMeta[];
+/**
+ * Extract all @Output() and output() signal metadata from a class declaration.
+ */
+export declare function extractOutputs(classDecl: ts.ClassDeclaration, checker: ts.TypeChecker): OutputMeta[];
+//# sourceMappingURL=input.extractor.d.ts.map

package/dist/builder/scanner/input.extractor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"input.extractor.d.ts","sourceRoot":"","sources":["../../../src/builder/scanner/input.extractor.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,YAAY,CAAC;AAC5B,OAAO,KAAK,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,8BAA8B,CAAC;AAG1E;;GAEG;AACH,wBAAgB,aAAa,CAAC,SAAS,EAAE,EAAE,CAAC,gBAAgB,EAAE,OAAO,EAAE,EAAE,CAAC,WAAW,GAAG,SAAS,EAAE,CAgClG;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,SAAS,EAAE,EAAE,CAAC,gBAAgB,EAAE,OAAO,EAAE,EAAE,CAAC,WAAW,GAAG,UAAU,EAAE,CAuBpG"}

package/dist/builder/scanner/input.extractor.js

@@ -0,0 +1,169 @@
+import ts from 'typescript';
+import { evaluateExpression, findDecorator, getDecoratorArgument, getJsDocComment } from './ast-utils.js';
+/**
+ * Extract all @Input(), input() and model() signal metadata from a class declaration.
+ */
+export function extractInputs(classDecl, checker) {
+    const inputs = [];
+    for (const member of classDecl.members) {
+        if (!ts.isPropertyDeclaration(member))
+            continue;
+        const name = member.name && ts.isIdentifier(member.name) ? member.name.text : undefined;
+        if (!name)
+            continue;
+        const inputDecorator = findDecorator(member, 'Input');
+        if (inputDecorator) {
+            const required = isDecoratorInputRequired(inputDecorator);
+            const defaultValue = member.initializer ? evaluateExpression(member.initializer) : undefined;
+            const doc = getJsDocComment(member, checker);
+            const { type, values, rawType } = resolveDecoratorInputType(member, checker);
+            inputs.push({ name, type, rawType, required, ...(values && { values }), ...(defaultValue !== undefined && { defaultValue }), ...(doc && { doc }) });
+            continue;
+        }
+        const signalCall = getInputSignalCall(member);
+        if (signalCall) {
+            const required = isSignalInputRequired(signalCall);
+            const defaultValue = !required && signalCall.arguments.length > 0
+                ? evaluateExpression(signalCall.arguments[0])
+                : undefined;
+            const doc = getJsDocComment(member, checker);
+            const { type, values, rawType } = resolveSignalInputType(signalCall, checker);
+            inputs.push({ name, type, rawType, required, ...(values && { values }), ...(defaultValue !== undefined && { defaultValue }), ...(doc && { doc }) });
+        }
+    }
+    return inputs;
+}
+/**
+ * Extract all @Output() and output() signal metadata from a class declaration.
+ */
+export function extractOutputs(classDecl, checker) {
+    const outputs = [];
+    for (const member of classDecl.members) {
+        if (!ts.isPropertyDeclaration(member))
+            continue;
+        const name = member.name && ts.isIdentifier(member.name) ? member.name.text : undefined;
+        if (!name)
+            continue;
+        const outputDecorator = findDecorator(member, 'Output');
+        if (outputDecorator) {
+            const doc = getJsDocComment(member, checker);
+            outputs.push({ name, ...(doc && { doc }) });
+            continue;
+        }
+        if (isOutputSignal(member)) {
+            const doc = getJsDocComment(member, checker);
+            outputs.push({ name, ...(doc && { doc }) });
+        }
+    }
+    return outputs;
+}
+function getInputSignalCall(member) {
+    const init = member.initializer;
+    if (!init || !ts.isCallExpression(init))
+        return null;
+    const expr = init.expression;
+    if (ts.isIdentifier(expr) && (expr.text === 'input' || expr.text === 'model'))
+        return init;
+    if (ts.isPropertyAccessExpression(expr) &&
+        ts.isIdentifier(expr.expression) && (expr.expression.text === 'input' || expr.expression.text === 'model') &&
+        ts.isIdentifier(expr.name) && expr.name.text === 'required') {
+        return init;
+    }
+    return null;
+}
+function isSignalInputRequired(callExpr) {
+    const expr = callExpr.expression;
+    return (ts.isPropertyAccessExpression(expr) &&
+        ts.isIdentifier(expr.name) &&
+        expr.name.text === 'required');
+}
+function isOutputSignal(member) {
+    const init = member.initializer;
+    if (!init || !ts.isCallExpression(init))
+        return false;
+    const expr = init.expression;
+    return ts.isIdentifier(expr) && expr.text === 'output';
+}
+function resolveSignalInputType(callExpr, checker) {
+    if (callExpr.typeArguments && callExpr.typeArguments.length > 0) {
+        const resolved = checker.getTypeFromTypeNode(callExpr.typeArguments[0]);
+        return mapType(resolved, checker);
+    }
+    if (callExpr.arguments.length > 0) {
+        const argType = checker.getTypeAtLocation(callExpr.arguments[0]);
+        return mapType(argType, checker);
+    }
+    return { type: 'unknown', rawType: 'unknown' };
+}
+function isDecoratorInputRequired(decorator) {
+    const arg = getDecoratorArgument(decorator);
+    if (!arg || !ts.isObjectLiteralExpression(arg))
+        return false;
+    for (const prop of arg.properties) {
+        if (ts.isPropertyAssignment(prop) &&
+            ts.isIdentifier(prop.name) &&
+            prop.name.text === 'required') {
+            return prop.initializer.kind === ts.SyntaxKind.TrueKeyword;
+        }
+    }
+    return false;
+}
+function resolveDecoratorInputType(member, checker) {
+    const tsType = checker.getTypeAtLocation(member);
+    return mapType(tsType, checker);
+}
+function getRawTypeLabel(tsType, checker) {
+    if (tsType.flags & (ts.TypeFlags.Boolean | ts.TypeFlags.BooleanLike | ts.TypeFlags.BooleanLiteral)) {
+        return 'boolean';
+    }
+    if (tsType.isUnion()) {
+        const meaningful = tsType.types.filter((t) => !(t.flags & ts.TypeFlags.Undefined) && !(t.flags & ts.TypeFlags.Null));
+        if (meaningful.length === 0)
+            return checker.typeToString(tsType);
+        if (meaningful.every((t) => t.flags & ts.TypeFlags.BooleanLiteral))
+            return 'boolean';
+        if (meaningful.length === 1)
+            return checker.typeToString(meaningful[0]);
+        if (tsType.aliasSymbol)
+            return tsType.aliasSymbol.getName();
+        return meaningful.map((t) => checker.typeToString(t)).join(' | ');
+    }
+    return checker.typeToString(tsType);
+}
+function mapType(tsType, checker) {
+    const rawType = getRawTypeLabel(tsType, checker);
+    if (tsType.flags & ts.TypeFlags.BooleanLike) {
+        return { type: 'boolean', rawType };
+    }
+    if (tsType.flags & ts.TypeFlags.Boolean) {
+        return { type: 'boolean', rawType };
+    }
+    if (tsType.isUnion()) {
+        const filtered = tsType.types.filter((t) => !(t.flags & ts.TypeFlags.Undefined) &&
+            !(t.flags & ts.TypeFlags.Null));
+        if (filtered.every((t) => t.flags & ts.TypeFlags.BooleanLiteral)) {
+            return { type: 'boolean', rawType };
+        }
+        if (filtered.every((t) => t.isStringLiteral())) {
+            const values = filtered.map((t) => t.value);
+            return { type: 'union', values, rawType };
+        }
+        if (filtered.length === 1) {
+            return { ...mapType(filtered[0], checker), rawType };
+        }
+        return { type: 'unknown', rawType };
+    }
+    if (tsType.flags & ts.TypeFlags.StringLike) {
+        return { type: 'string', rawType };
+    }
+    if (tsType.flags & ts.TypeFlags.NumberLike) {
+        return { type: 'number', rawType };
+    }
+    if (checker.isArrayType(tsType)) {
+        return { type: 'array', rawType };
+    }
+    if (tsType.flags & ts.TypeFlags.Object) {
+        return { type: 'object', rawType };
+    }
+    return { type: 'unknown', rawType };
+}

package/dist/builder/scanner/manifest.generator.d.ts

@@ -0,0 +1,6 @@
+import type { ScannedComponent } from '../../plugin/plugin.types.js';
+/**
+ * Generate TypeScript source code for a prism-manifest.ts file.
+ */
+export declare function generateManifest(components: ScannedComponent[]): string;
+//# sourceMappingURL=manifest.generator.d.ts.map

package/dist/builder/scanner/manifest.generator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"manifest.generator.d.ts","sourceRoot":"","sources":["../../../src/builder/scanner/manifest.generator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,8BAA8B,CAAC;AAErE;;GAEG;AACH,wBAAgB,gBAAgB,CAC9B,UAAU,EAAE,gBAAgB,EAAE,GAC7B,MAAM,CAyBR"}

package/dist/builder/scanner/manifest.generator.js

@@ -0,0 +1,59 @@
+/**
+ * Generate TypeScript source code for a prism-manifest.ts file.
+ */
+export function generateManifest(components) {
+    const lines = [
+        '// AUTO-GENERATED by ng-prism — do not edit!',
+        "import type { PrismManifest } from 'ng-prism/plugin';",
+        '',
+        'export const PRISM_MANIFEST: PrismManifest = {',
+        '  components: [',
+    ];
+    for (const comp of components) {
+        lines.push('    {');
+        lines.push(`      className: ${json(comp.className)},`);
+        lines.push(`      filePath: ${json(comp.filePath)},`);
+        lines.push(`      showcaseConfig: ${formatObject(comp.showcaseConfig, 6)},`);
+        lines.push(`      inputs: ${formatArray(comp.inputs, 6)},`);
+        lines.push(`      outputs: ${formatArray(comp.outputs, 6)},`);
+        lines.push(`      componentMeta: ${formatObject(comp.componentMeta, 6)},`);
+        lines.push('    },');
+    }
+    lines.push('  ],');
+    lines.push('};');
+    lines.push('');
+    return lines.join('\n');
+}
+function json(value) {
+    return JSON.stringify(value);
+}
+function indent(depth) {
+    return ' '.repeat(depth);
+}
+function formatObject(obj, baseIndent) {
+    const entries = Object.entries(obj).filter(([, v]) => v !== undefined);
+    if (entries.length === 0)
+        return '{}';
+    const inner = baseIndent + 2;
+    const lines = entries.map(([key, value]) => {
+        const formatted = Array.isArray(value)
+            ? formatArray(value, inner)
+            : typeof value === 'object' && value !== null
+                ? formatObject(value, inner)
+                : json(value);
+        return `${indent(inner)}${key}: ${formatted},`;
+    });
+    return `{\n${lines.join('\n')}\n${indent(baseIndent)}}`;
+}
+function formatArray(arr, baseIndent) {
+    if (arr.length === 0)
+        return '[]';
+    const inner = baseIndent + 2;
+    const items = arr.map((item) => {
+        const formatted = typeof item === 'object' && item !== null && !Array.isArray(item)
+            ? formatObject(item, inner)
+            : json(item);
+        return `${indent(inner)}${formatted},`;
+    });
+    return `[\n${items.join('\n')}\n${indent(baseIndent)}]`;
+}