@ng-prism/core 21.6.1 → 21.7.0

package/dist/schematics/ng-add/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/schematics/ng-add/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,IAAI,EAIV,MAAM,4BAA4B,CAAC;AAEpC,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AAqOtD,wBAAgB,KAAK,CAAC,OAAO,EAAE,kBAAkB,GAAG,IAAI,CAOvD"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/schematics/ng-add/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,IAAI,EAIV,MAAM,4BAA4B,CAAC;AAEpC,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AA6RtD,wBAAgB,KAAK,CAAC,OAAO,EAAE,kBAAkB,GAAG,IAAI,CAUvD"}

package/dist/schematics/ng-add/index.js

@@ -173,11 +173,62 @@ function createConfigFile() {
         return tree;
     };
 }
+function addGitignoreEntry(options) {
+    return (tree) => {
+        const prismProjectName = `${options.project}-prism`;
+        const entry = `projects/${prismProjectName}/src/prism-manifest.ts`;
+        const gitignorePath = '.gitignore';
+        const buffer = tree.read(gitignorePath);
+        if (buffer) {
+            const content = buffer.toString('utf-8');
+            if (content.includes(entry))
+                return tree;
+            tree.overwrite(gitignorePath, content.trimEnd() + '\n' + entry + '\n');
+        }
+        else {
+            tree.create(gitignorePath, entry + '\n');
+        }
+        return tree;
+    };
+}
+function logSetupSummary(options) {
+    return (_tree, context) => {
+        const prismProjectName = `${options.project}-prism`;
+        context.logger.info('');
+        context.logger.info('ng-prism setup complete:');
+        context.logger.info(`  Prism app project: ${prismProjectName}`);
+        context.logger.info(`  Config file:       ng-prism.config.ts`);
+        context.logger.info(`  Dev server:        ng run ${options.project}:prism`);
+        context.logger.info(`  Production build:  ng run ${options.project}:prism-build`);
+        context.logger.info(`  Strip decorators:  npm run strip-showcase`);
+        context.logger.info('');
+    };
+}
+function addStripShowcaseScript(options) {
+    return (tree) => {
+        const pkgPath = 'package.json';
+        const buffer = tree.read(pkgPath);
+        if (!buffer)
+            return tree;
+        const pkg = JSON.parse(buffer.toString('utf-8'));
+        if (!pkg.scripts)
+            pkg.scripts = {};
+        const scriptName = 'strip-showcase';
+        if (pkg.scripts[scriptName])
+            return tree;
+        pkg.scripts[scriptName] = `ng-prism-strip dist/${options.project}`;
+        tree.overwrite(pkgPath, JSON.stringify(pkg, null, 2) + '\n');
+        return tree;
+    };
+}
 export function ngAdd(options) {
     return chain([
         addPrismAppProject(options),
         addBuilderTargets(options),
         addTsConfigPaths(options),
         createConfigFile(),
+        addStripShowcaseScript(options),
+        addGitignoreEntry(options),
+        logSetupSummary(options),
     ]);
 }

package/dist/transformer/cli.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=cli.d.ts.map

package/dist/transformer/cli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../../src/transformer/cli.ts"],"names":[],"mappings":""}

package/dist/transformer/cli.js

@@ -0,0 +1,13 @@
+#!/usr/bin/env node
+import { stripShowcaseFromDirectory } from './strip-directory.js';
+const dir = process.argv[2];
+if (!dir) {
+    console.error('Usage: ng-prism-strip <dist-dir>');
+    process.exit(1);
+}
+stripShowcaseFromDirectory(dir).then((result) => {
+    console.log(`Stripped @Showcase from ${result.strippedFiles} of ${result.totalFiles} files.`);
+}, (error) => {
+    console.error(`Error: ${error.message}`);
+    process.exit(1);
+});

package/dist/transformer/index.d.ts

@@ -0,0 +1,3 @@
+export { createShowcaseStripTransformer, stripShowcaseDecorators, } from './showcase-strip.transformer.js';
+export { stripShowcaseFromDirectory, type StripResult, } from './strip-directory.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/transformer/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/transformer/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,8BAA8B,EAC9B,uBAAuB,GACxB,MAAM,iCAAiC,CAAC;AACzC,OAAO,EACL,0BAA0B,EAC1B,KAAK,WAAW,GACjB,MAAM,sBAAsB,CAAC"}

package/dist/transformer/index.js

@@ -0,0 +1,2 @@
+export { createShowcaseStripTransformer, stripShowcaseDecorators, } from './showcase-strip.transformer.js';
+export { stripShowcaseFromDirectory, } from './strip-directory.js';

package/dist/transformer/showcase-strip.transformer.d.ts

@@ -0,0 +1,4 @@
+import ts from 'typescript';
+export declare function createShowcaseStripTransformer(): ts.TransformerFactory<ts.SourceFile>;
+export declare function stripShowcaseDecorators(source: string, fileName?: string): string;
+//# sourceMappingURL=showcase-strip.transformer.d.ts.map

package/dist/transformer/showcase-strip.transformer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"showcase-strip.transformer.d.ts","sourceRoot":"","sources":["../../src/transformer/showcase-strip.transformer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,YAAY,CAAC;AAmK5B,wBAAgB,8BAA8B,IAAI,EAAE,CAAC,kBAAkB,CAAC,EAAE,CAAC,UAAU,CAAC,CAuCrF;AAED,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,SAAY,GAAG,MAAM,CAWpF"}

package/dist/transformer/showcase-strip.transformer.js

@@ -0,0 +1,147 @@
+import ts from 'typescript';
+const SHOWCASE_MODULE_PREFIXES = ['@ng-prism/core', 'ng-prism'];
+function isShowcaseModule(specifier) {
+    return SHOWCASE_MODULE_PREFIXES.some((prefix) => specifier === prefix || specifier.startsWith(prefix + '/'));
+}
+function isShowcaseCall(expr, names) {
+    return ts.isCallExpression(expr)
+        && ts.isIdentifier(expr.expression)
+        && names.has(expr.expression.text);
+}
+function isLoweredShowcaseCall(expr, names) {
+    if (!ts.isCallExpression(expr))
+        return false;
+    return isShowcaseCall(expr.expression, names);
+}
+function tryHandleDecorateStatement(stmt, names, factory) {
+    const expr = stmt.expression;
+    if (!ts.isBinaryExpression(expr) || expr.operatorToken.kind !== ts.SyntaxKind.EqualsToken) {
+        return undefined;
+    }
+    const rhs = expr.right;
+    if (!ts.isCallExpression(rhs) || !ts.isIdentifier(rhs.expression) || rhs.expression.text !== '__decorate') {
+        return undefined;
+    }
+    const args = rhs.arguments;
+    if (args.length < 2 || !ts.isArrayLiteralExpression(args[0])) {
+        return undefined;
+    }
+    const decoratorArray = args[0];
+    const hasShowcase = decoratorArray.elements.some((el) => isShowcaseCall(el, names));
+    if (!hasShowcase)
+        return undefined;
+    const remaining = decoratorArray.elements.filter((el) => !isShowcaseCall(el, names));
+    if (remaining.length === 0) {
+        return { action: 'remove' };
+    }
+    const newArray = factory.updateArrayLiteralExpression(decoratorArray, remaining);
+    const newCall = factory.updateCallExpression(rhs, rhs.expression, rhs.typeArguments, [newArray, ...args.slice(1)]);
+    const newBinary = factory.updateBinaryExpression(expr, expr.left, expr.operatorToken, newCall);
+    const newStmt = factory.updateExpressionStatement(stmt, newBinary);
+    return { action: 'replace', statement: newStmt };
+}
+function isShowcaseDecorator(d, names) {
+    return ts.isCallExpression(d.expression)
+        && ts.isIdentifier(d.expression.expression)
+        && names.has(d.expression.expression.text);
+}
+function stripNativeDecorators(node, names, factory) {
+    const decorators = ts.getDecorators(node);
+    if (!decorators)
+        return undefined;
+    const keptDecorators = decorators.filter((d) => !isShowcaseDecorator(d, names));
+    if (keptDecorators.length === decorators.length)
+        return undefined;
+    const modifiers = ts.getModifiers(node) ?? [];
+    return factory.updateClassDeclaration(node, [...keptDecorators, ...modifiers], node.name, node.typeParameters, node.heritageClauses, node.members);
+}
+function findShowcaseImports(sourceFile) {
+    const localNames = new Set();
+    const declarations = new Set();
+    for (const stmt of sourceFile.statements) {
+        if (!ts.isImportDeclaration(stmt))
+            continue;
+        if (!ts.isStringLiteral(stmt.moduleSpecifier))
+            continue;
+        if (!isShowcaseModule(stmt.moduleSpecifier.text))
+            continue;
+        const namedBindings = stmt.importClause?.namedBindings;
+        if (!namedBindings || !ts.isNamedImports(namedBindings))
+            continue;
+        for (const spec of namedBindings.elements) {
+            const importedName = (spec.propertyName ?? spec.name).text;
+            if (importedName === 'Showcase') {
+                localNames.add(spec.name.text);
+                declarations.add(stmt);
+            }
+        }
+    }
+    return { localNames, declarations };
+}
+function cleanupImports(statements, info, factory) {
+    return statements.reduce((acc, stmt) => {
+        if (!ts.isImportDeclaration(stmt) || !info.declarations.has(stmt)) {
+            acc.push(stmt);
+            return acc;
+        }
+        const namedBindings = stmt.importClause?.namedBindings;
+        if (!namedBindings || !ts.isNamedImports(namedBindings)) {
+            acc.push(stmt);
+            return acc;
+        }
+        const remaining = namedBindings.elements.filter((spec) => {
+            const importedName = (spec.propertyName ?? spec.name).text;
+            return importedName !== 'Showcase';
+        });
+        if (remaining.length === 0)
+            return acc;
+        acc.push(factory.updateImportDeclaration(stmt, stmt.modifiers, factory.updateImportClause(stmt.importClause, stmt.importClause.isTypeOnly, stmt.importClause.name, factory.updateNamedImports(namedBindings, remaining)), stmt.moduleSpecifier, stmt.attributes));
+        return acc;
+    }, []);
+}
+export function createShowcaseStripTransformer() {
+    return (context) => {
+        const factory = context.factory;
+        return (sourceFile) => {
+            const importInfo = findShowcaseImports(sourceFile);
+            if (importInfo.localNames.size === 0)
+                return sourceFile;
+            const names = importInfo.localNames;
+            const filtered = [];
+            for (const stmt of sourceFile.statements) {
+                if (ts.isExpressionStatement(stmt)) {
+                    if (isLoweredShowcaseCall(stmt.expression, names))
+                        continue;
+                    const decorateResult = tryHandleDecorateStatement(stmt, names, factory);
+                    if (decorateResult) {
+                        if (decorateResult.action === 'replace' && decorateResult.statement) {
+                            filtered.push(decorateResult.statement);
+                        }
+                        continue;
+                    }
+                }
+                if (ts.isClassDeclaration(stmt)) {
+                    const stripped = stripNativeDecorators(stmt, names, factory);
+                    if (stripped) {
+                        filtered.push(stripped);
+                        continue;
+                    }
+                }
+                filtered.push(stmt);
+            }
+            const cleaned = cleanupImports(filtered, importInfo, factory);
+            return factory.updateSourceFile(sourceFile, cleaned);
+        };
+    };
+}
+export function stripShowcaseDecorators(source, fileName = 'file.ts') {
+    const sourceFile = ts.createSourceFile(fileName, source, ts.ScriptTarget.Latest, true);
+    const importInfo = findShowcaseImports(sourceFile);
+    if (importInfo.localNames.size === 0)
+        return source;
+    const result = ts.transform(sourceFile, [createShowcaseStripTransformer()]);
+    const printer = ts.createPrinter({ newLine: ts.NewLineKind.LineFeed });
+    const output = printer.printFile(result.transformed[0]);
+    result.dispose();
+    return output;
+}

package/dist/transformer/strip-directory.d.ts

@@ -0,0 +1,6 @@
+export interface StripResult {
+    totalFiles: number;
+    strippedFiles: number;
+}
+export declare function stripShowcaseFromDirectory(dir: string): Promise<StripResult>;
+//# sourceMappingURL=strip-directory.d.ts.map

package/dist/transformer/strip-directory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"strip-directory.d.ts","sourceRoot":"","sources":["../../src/transformer/strip-directory.ts"],"names":[],"mappings":"AAIA,MAAM,WAAW,WAAW;IAC1B,UAAU,EAAE,MAAM,CAAC;IACnB,aAAa,EAAE,MAAM,CAAC;CACvB;AAID,wBAAsB,0BAA0B,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,CAAC,CAkBlF"}

package/dist/transformer/strip-directory.js

@@ -0,0 +1,20 @@
+import { readdir, readFile, writeFile } from 'node:fs/promises';
+import { join, extname } from 'node:path';
+import { stripShowcaseDecorators } from './showcase-strip.transformer.js';
+const JS_EXTENSIONS = new Set(['.js', '.mjs']);
+export async function stripShowcaseFromDirectory(dir) {
+    const entries = await readdir(dir, { recursive: true });
+    const files = entries
+        .filter((entry) => JS_EXTENSIONS.has(extname(entry)))
+        .map((entry) => join(dir, entry));
+    let strippedFiles = 0;
+    for (const file of files) {
+        const source = await readFile(file, 'utf-8');
+        const result = stripShowcaseDecorators(source, file);
+        if (result !== source) {
+            await writeFile(file, result, 'utf-8');
+            strippedFiles++;
+        }
+    }
+    return { totalFiles: files.length, strippedFiles };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ng-prism/core",
-  "version": "21.6.1",
+  "version": "21.7.0",
   "description": "Lightweight Angular-native component showcase — no story files needed.",
   "keywords": [
     "angular",
@@ -30,8 +30,16 @@
       "types": "./dist/plugin/index.d.ts",
       "import": "./dist/plugin/index.js",
       "default": "./dist/plugin/index.js"
+    },
+    "./transformer": {
+      "types": "./dist/transformer/index.d.ts",
+      "import": "./dist/transformer/index.js",
+      "default": "./dist/transformer/index.js"
     }
   },
+  "bin": {
+    "ng-prism-strip": "./dist/transformer/cli.js"
+  },
   "schematics": "./schematics/collection.json",
   "builders": "./builders.json",
   "files": [