@caryhu/codemine-forge 0.0.1-alpha.2 → 0.0.1-alpha.4

package/dist/build-pipeline/angular-resources.d.ts

@@ -0,0 +1,12 @@
+import type { ForgeVirtualFileSystem } from "../virtual-file-system";
+import type { ForgeBuildPipelineDiagnostic } from "./types";
+export interface InlineAngularComponentResourcesOptions {
+    readonly fileSystem: ForgeVirtualFileSystem;
+    readonly sourcePath: string;
+    readonly sourceText: string;
+}
+export interface InlineAngularComponentResourcesResult {
+    readonly outputText: string;
+    readonly diagnostics: readonly ForgeBuildPipelineDiagnostic[];
+}
+export declare function inlineAngularComponentResources(options: InlineAngularComponentResourcesOptions): Promise<InlineAngularComponentResourcesResult>;

package/dist/build-pipeline/angular-resources.js

@@ -0,0 +1,316 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.inlineAngularComponentResources = void 0;
+const ts = __importStar(require("typescript"));
+const virtual_file_system_1 = require("../virtual-file-system");
+const diagnostics_1 = require("./diagnostics");
+const COMPONENT_RESOURCE_PROPERTIES = new Set([
+    "templateUrl",
+    "styleUrl",
+    "styleUrls",
+]);
+async function inlineAngularComponentResources(options) {
+    try {
+        const sourceFile = ts.createSourceFile(options.sourcePath, options.sourceText, ts.ScriptTarget.Latest, true, getScriptKind(options.sourcePath));
+        const componentObjects = collectComponentMetadataObjects(sourceFile);
+        if (componentObjects.length === 0) {
+            return {
+                outputText: options.sourceText,
+                diagnostics: [],
+            };
+        }
+        const diagnostics = [];
+        const rewrites = new Map();
+        for (const componentObject of componentObjects) {
+            const rewrite = await createComponentObjectRewrite(options, componentObject);
+            diagnostics.push(...rewrite.diagnostics);
+            if (rewrite.value !== undefined) {
+                rewrites.set(componentObject, rewrite.value);
+            }
+        }
+        if (diagnostics.length > 0) {
+            return {
+                outputText: options.sourceText,
+                diagnostics,
+            };
+        }
+        if (rewrites.size === 0) {
+            return {
+                outputText: options.sourceText,
+                diagnostics: [],
+            };
+        }
+        const transformer = (context) => {
+            const visitor = (node) => {
+                if (ts.isCallExpression(node) &&
+                    node.arguments.length > 0 &&
+                    ts.isObjectLiteralExpression(node.arguments[0]) &&
+                    isAngularComponentDecoratorCall(node)) {
+                    const componentObject = node.arguments[0];
+                    const rewrite = rewrites.get(componentObject);
+                    if (rewrite !== undefined) {
+                        return ts.factory.updateCallExpression(node, node.expression, node.typeArguments, [
+                            updateComponentObjectLiteral(componentObject, rewrite),
+                            ...node.arguments.slice(1),
+                        ]);
+                    }
+                }
+                return ts.visitEachChild(node, visitor, context);
+            };
+            return (node) => ts.visitNode(node, visitor);
+        };
+        const result = ts.transform(sourceFile, [transformer]);
+        try {
+            const transformedSourceFile = result.transformed[0];
+            const printer = ts.createPrinter({
+                newLine: ts.NewLineKind.LineFeed,
+            });
+            return {
+                outputText: printer.printFile(transformedSourceFile),
+                diagnostics: [],
+            };
+        }
+        finally {
+            result.dispose();
+        }
+    }
+    catch (error) {
+        return {
+            outputText: options.sourceText,
+            diagnostics: [
+                (0, diagnostics_1.createAngularResourceTransformFailedDiagnostic)(options.sourcePath, error),
+            ],
+        };
+    }
+}
+exports.inlineAngularComponentResources = inlineAngularComponentResources;
+function collectComponentMetadataObjects(sourceFile) {
+    const componentObjects = [];
+    function visit(node) {
+        if (ts.isCallExpression(node) &&
+            node.arguments.length > 0 &&
+            ts.isObjectLiteralExpression(node.arguments[0]) &&
+            isAngularComponentDecoratorCall(node) &&
+            hasComponentResourceProperty(node.arguments[0])) {
+            componentObjects.push(node.arguments[0]);
+        }
+        ts.forEachChild(node, visit);
+    }
+    visit(sourceFile);
+    return componentObjects;
+}
+async function createComponentObjectRewrite(options, componentObject) {
+    const diagnostics = [];
+    const styleResourceProperties = new Set();
+    const styleResources = [];
+    const templateResources = new Map();
+    for (const property of componentObject.properties) {
+        if (!ts.isPropertyAssignment(property)) {
+            continue;
+        }
+        const propertyName = getPropertyNameText(property.name);
+        if (propertyName === "templateUrl") {
+            const resourcePath = getStringLiteralText(property.initializer);
+            if (resourcePath === undefined) {
+                continue;
+            }
+            const resource = await readComponentResource(options, resourcePath);
+            diagnostics.push(...resource.diagnostics);
+            if (resource.content !== undefined) {
+                templateResources.set(property, resource.content);
+            }
+            continue;
+        }
+        if (propertyName === "styleUrl") {
+            const resourcePath = getStringLiteralText(property.initializer);
+            if (resourcePath === undefined) {
+                continue;
+            }
+            const resource = await readComponentResource(options, resourcePath);
+            diagnostics.push(...resource.diagnostics);
+            if (resource.content !== undefined) {
+                styleResourceProperties.add(property);
+                styleResources.push(resource.content);
+            }
+            continue;
+        }
+        if (propertyName === "styleUrls") {
+            const resourcePaths = getStringArrayLiteralText(property.initializer);
+            if (resourcePaths === undefined) {
+                continue;
+            }
+            for (const resourcePath of resourcePaths) {
+                const resource = await readComponentResource(options, resourcePath);
+                diagnostics.push(...resource.diagnostics);
+                if (resource.content !== undefined) {
+                    styleResources.push(resource.content);
+                }
+            }
+            if (resourcePaths.length > 0) {
+                styleResourceProperties.add(property);
+            }
+        }
+    }
+    if (diagnostics.length > 0 ||
+        (styleResources.length === 0 && templateResources.size === 0)) {
+        return { diagnostics };
+    }
+    return {
+        value: {
+            styleResourceProperties,
+            styleResources,
+            templateResources,
+        },
+        diagnostics,
+    };
+}
+function updateComponentObjectLiteral(componentObject, rewrite) {
+    const existingStylesProperty = componentObject.properties.find((property) => ts.isPropertyAssignment(property) &&
+        getPropertyNameText(property.name) === "styles");
+    const firstStyleResourceProperty = componentObject.properties.find((property) => ts.isPropertyAssignment(property) &&
+        rewrite.styleResourceProperties.has(property));
+    const updatedProperties = [];
+    for (const property of componentObject.properties) {
+        if (ts.isPropertyAssignment(property) &&
+            rewrite.templateResources.has(property)) {
+            updatedProperties.push(ts.factory.createPropertyAssignment("template", ts.factory.createStringLiteral(rewrite.templateResources.get(property) ?? "")));
+            continue;
+        }
+        if (ts.isPropertyAssignment(property) &&
+            rewrite.styleResourceProperties.has(property)) {
+            if (existingStylesProperty === undefined &&
+                property === firstStyleResourceProperty) {
+                updatedProperties.push(createStylesProperty(rewrite.styleResources));
+            }
+            continue;
+        }
+        if (property === existingStylesProperty) {
+            updatedProperties.push(updateStylesProperty(existingStylesProperty, rewrite.styleResources));
+            continue;
+        }
+        updatedProperties.push(property);
+    }
+    if (existingStylesProperty === undefined &&
+        firstStyleResourceProperty === undefined &&
+        rewrite.styleResources.length > 0) {
+        updatedProperties.push(createStylesProperty(rewrite.styleResources));
+    }
+    return ts.factory.updateObjectLiteralExpression(componentObject, updatedProperties);
+}
+function createStylesProperty(styles) {
+    return ts.factory.createPropertyAssignment("styles", ts.factory.createArrayLiteralExpression(styles.map((style) => ts.factory.createStringLiteral(style))));
+}
+function updateStylesProperty(property, styleResources) {
+    const existingStyles = ts.isArrayLiteralExpression(property.initializer)
+        ? property.initializer.elements
+        : [property.initializer];
+    return ts.factory.updatePropertyAssignment(property, property.name, ts.factory.createArrayLiteralExpression([
+        ...existingStyles,
+        ...styleResources.map((style) => ts.factory.createStringLiteral(style)),
+    ]));
+}
+async function readComponentResource(options, resourcePath) {
+    if (isExternalResourceUrl(resourcePath)) {
+        return {
+            diagnostics: [
+                (0, diagnostics_1.createAngularExternalResourceUnsupportedDiagnostic)(options.sourcePath, resourcePath),
+            ],
+        };
+    }
+    for (const candidate of createResourcePathCandidates(options.sourcePath, resourcePath)) {
+        if (await options.fileSystem.exists(candidate)) {
+            return {
+                content: await options.fileSystem.readText(candidate),
+                diagnostics: [],
+            };
+        }
+    }
+    return {
+        diagnostics: [
+            (0, diagnostics_1.createAngularResourceNotFoundDiagnostic)(options.sourcePath, resourcePath),
+        ],
+    };
+}
+function createResourcePathCandidates(sourcePath, resourcePath) {
+    const candidates = [];
+    const relativeCandidate = resourcePath.startsWith("/")
+        ? resourcePath
+        : `${dirname(sourcePath)}/${resourcePath}`;
+    const rootCandidate = resourcePath.startsWith("/")
+        ? resourcePath
+        : `/${resourcePath.replace(/^\.\//, "")}`;
+    for (const candidate of [relativeCandidate, rootCandidate]) {
+        const normalized = (0, virtual_file_system_1.normalizeForgePath)(candidate);
+        if (normalized.ok && !candidates.includes(normalized.path)) {
+            candidates.push(normalized.path);
+        }
+    }
+    return candidates;
+}
+function hasComponentResourceProperty(componentObject) {
+    return componentObject.properties.some((property) => ts.isPropertyAssignment(property) &&
+        COMPONENT_RESOURCE_PROPERTIES.has(getPropertyNameText(property.name) ?? ""));
+}
+function isAngularComponentDecoratorCall(node) {
+    return (ts.isDecorator(node.parent) &&
+        ts.isIdentifier(node.expression) &&
+        node.expression.text === "Component");
+}
+function getPropertyNameText(name) {
+    if (ts.isIdentifier(name) || ts.isStringLiteral(name)) {
+        return name.text;
+    }
+    return undefined;
+}
+function getStringLiteralText(node) {
+    return ts.isStringLiteral(node) || ts.isNoSubstitutionTemplateLiteral(node)
+        ? node.text
+        : undefined;
+}
+function getStringArrayLiteralText(node) {
+    if (!ts.isArrayLiteralExpression(node)) {
+        return undefined;
+    }
+    const values = [];
+    for (const element of node.elements) {
+        const value = getStringLiteralText(element);
+        if (value === undefined) {
+            return undefined;
+        }
+        values.push(value);
+    }
+    return values;
+}
+function isExternalResourceUrl(resourcePath) {
+    return /^(?:https?:|data:|blob:)/i.test(resourcePath);
+}
+function getScriptKind(path) {
+    return path.endsWith(".tsx") ? ts.ScriptKind.TSX : ts.ScriptKind.TS;
+}
+function dirname(path) {
+    const index = path.lastIndexOf("/");
+    return index <= 0 ? "/" : path.slice(0, index);
+}

package/dist/build-pipeline/browser-bundle.d.ts

@@ -10,9 +10,15 @@ interface CreateBrowserBundleOptions {
     readonly entry: string;
     readonly fileSystem: ForgeVirtualFileSystem;
     readonly packageResolution: ForgePackageResolutionResult;
+    readonly angularCompatibility?: ForgeBrowserBundleAngularCompatibility;
     readonly scriptTransformer?: ForgeBrowserBundleScriptTransformer;
     readonly viteConfig?: ForgeViteConfigMetadata;
 }
+interface ForgeBrowserBundleAngularCompatibility {
+    readonly injectZoneJs: boolean;
+    readonly inlineComponentResources: boolean;
+    readonly linker: "auto" | "diagnostic" | "disabled";
+}
 export type ForgeBrowserBundleScriptLoader = "ts" | "tsx";
 export interface ForgeBrowserBundleScriptTransformRequest {
     readonly loader: ForgeBrowserBundleScriptLoader;