@caryhu/codemine-forge 0.0.1-alpha.3 → 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;

package/dist/build-pipeline/browser-bundle.js

@@ -27,6 +27,7 @@ exports.createBrowserBundle = void 0;
 const compiler_sfc_1 = require("@vue/compiler-sfc");
 const ts = __importStar(require("typescript"));
 const virtual_file_system_1 = require("../virtual-file-system");
+const angular_resources_1 = require("./angular-resources");
 const diagnostics_1 = require("./diagnostics");
 const BROWSER_IMPORT_MAP_PATH = "/.forge/build/browser-import-map.json";
 const DEFAULT_RESOLVE_EXTENSIONS = [
@@ -77,7 +78,7 @@ async function createBrowserBundle(options) {
             visiting.delete(sourcePath);
             return;
         }
-        const source = await options.fileSystem.readText(sourcePath);
+        const source = maybeInjectAngularZoneJsImport(sourcePath, options.entry, await options.fileSystem.readText(sourcePath), options.angularCompatibility);
         const importSource = extension === ".vue" ? createVueSfcModule(sourcePath, source) : source;
         const imports = extractImportReferences(importSource).map((reference) => reference.specifier);
         const rewrites = new Map();
@@ -114,11 +115,18 @@ async function createBrowserBundle(options) {
             packageImports.set(specifier, packageImport.kind === "external"
                 ? packageImport.url
                 : packageImport.outputPath);
+            const linkerDiagnostic = packageImport.kind === "external"
+                ? createExternalAngularPartialLinkerDiagnostic(packageImport.packageRecord, options.angularCompatibility)
+                : undefined;
+            if (linkerDiagnostic !== undefined) {
+                diagnostics.push(linkerDiagnostic);
+                continue;
+            }
             if (packageImport.kind === "package-file") {
                 await visitPackageModule(packageImport.packageRecord, packageImport.filePath);
             }
         }
-        const transformResult = await transformWorkspaceModule(sourcePath, source, options.scriptTransformer, options.viteConfig?.define ?? {});
+        const transformResult = await transformWorkspaceModule(sourcePath, source, options.fileSystem, options.angularCompatibility, options.scriptTransformer, options.viteConfig?.define ?? {});
         if (!transformResult.success) {
             diagnostics.push(...transformResult.diagnostics);
             visiting.delete(sourcePath);
@@ -177,11 +185,18 @@ async function createBrowserBundle(options) {
             packageImports.set(specifier, packageImport.kind === "external"
                 ? packageImport.url
                 : packageImport.outputPath);
+            const linkerDiagnostic = packageImport.kind === "external"
+                ? createExternalAngularPartialLinkerDiagnostic(packageImport.packageRecord, options.angularCompatibility)
+                : undefined;
+            if (linkerDiagnostic !== undefined) {
+                diagnostics.push(linkerDiagnostic);
+                continue;
+            }
             if (packageImport.kind === "package-file") {
                 await visitPackageModule(packageImport.packageRecord, packageImport.filePath);
             }
         }
-        const transformResult = transformPackageModule(importer, normalizedFilePath, content);
+        const transformResult = transformPackageModule(importer, normalizedFilePath, content, packageRecord, options.angularCompatibility);
         if (!transformResult.success) {
             diagnostics.push(...transformResult.diagnostics);
             visitingPackageModules.delete(key);
@@ -254,7 +269,7 @@ function createBrowserBundleModules(workspaceModules, packageModules) {
         })),
     ].sort((left, right) => left.outputPath.localeCompare(right.outputPath));
 }
-async function transformWorkspaceModule(sourcePath, source, scriptTransformer, defineReplacements) {
+async function transformWorkspaceModule(sourcePath, source, fileSystem, angularCompatibility, scriptTransformer, defineReplacements) {
     const extension = getExtension(sourcePath);
     if (extension === ".css") {
         return transformSuccess(createWorkspaceCssModule(sourcePath, source));
@@ -269,18 +284,35 @@ async function transformWorkspaceModule(sourcePath, source, scriptTransformer, d
     if (!SCRIPT_EXTENSIONS.has(extension)) {
         return transformSuccess(source);
     }
+    const angularResourceResult = angularCompatibility?.inlineComponentResources === true
+        ? await (0, angular_resources_1.inlineAngularComponentResources)({
+            fileSystem,
+            sourcePath,
+            sourceText: source,
+        })
+        : {
+            outputText: source,
+            diagnostics: [],
+        };
+    if (angularResourceResult.diagnostics.length > 0) {
+        return {
+            success: false,
+            diagnostics: angularResourceResult.diagnostics,
+        };
+    }
+    const sourceText = angularResourceResult.outputText;
     const loader = scriptLoaderForExtension(extension);
     if (loader !== undefined && scriptTransformer !== undefined) {
         const transformResult = await scriptTransformer({
             loader,
             sourcePath,
-            sourceText: source,
+            sourceText,
         });
         return transformResult.success
             ? transformSuccess(applyDefines(transformResult.outputText))
             : transformResult;
     }
-    return transformSuccess(applyDefines(transpileScript(sourcePath, source)));
+    return transformSuccess(applyDefines(transpileScript(sourcePath, sourceText)));
 }
 function transpileScript(sourcePath, source) {
     return ts.transpileModule(source, {
@@ -304,7 +336,7 @@ function transformSuccess(outputText) {
         diagnostics: [],
     };
 }
-function transformPackageModule(importer, filePath, content) {
+function transformPackageModule(importer, filePath, content, packageRecord, angularCompatibility) {
     const extension = getExtension(filePath);
     if (typeof content !== "string" &&
         !SCRIPT_EXTENSIONS.has(extension) &&
@@ -322,8 +354,52 @@ function transformPackageModule(importer, filePath, content) {
     if (!SCRIPT_EXTENSIONS.has(extension)) {
         return transformSuccess(source);
     }
+    if (shouldDiagnoseAngularPartialDeclarations(angularCompatibility) &&
+        hasAngularPartialDeclaration(source)) {
+        return {
+            success: false,
+            diagnostics: [
+                (0, diagnostics_1.createAngularPartialLinkerRequiredDiagnostic)(packageRecord.name, packageRecord.version, importer),
+            ],
+        };
+    }
     return transformSuccess(transpileScript(importer, source));
 }
+function maybeInjectAngularZoneJsImport(sourcePath, entry, source, angularCompatibility) {
+    if (angularCompatibility?.injectZoneJs !== true ||
+        sourcePath !== entry ||
+        hasBareImport(source, "zone.js")) {
+        return source;
+    }
+    return `import "zone.js";\n${source}`;
+}
+function createExternalAngularPartialLinkerDiagnostic(packageRecord, angularCompatibility) {
+    if (!shouldDiagnoseAngularPartialDeclarations(angularCompatibility) ||
+        !packageRecordHasAngularPartialDeclaration(packageRecord)) {
+        return undefined;
+    }
+    return (0, diagnostics_1.createAngularPartialLinkerRequiredDiagnostic)(packageRecord.name, packageRecord.version, packageRecord.entryUrl ?? createPackageImporterPath(packageRecord, packageRecord.entry));
+}
+function shouldDiagnoseAngularPartialDeclarations(angularCompatibility) {
+    return angularCompatibility?.linker === "auto" ||
+        angularCompatibility?.linker === "diagnostic";
+}
+function packageRecordHasAngularPartialDeclaration(packageRecord) {
+    return Object.values(packageRecord.files).some((file) => typeof file.content === "string" &&
+        hasAngularPartialDeclaration(file.content));
+}
+function hasAngularPartialDeclaration(source) {
+    return ANGULAR_PARTIAL_DECLARATION_MARKERS.some((marker) => source.includes(marker));
+}
+const ANGULAR_PARTIAL_DECLARATION_MARKERS = [
+    "\u0275\u0275ngDeclareComponent",
+    "\u0275\u0275ngDeclareDirective",
+    "\u0275\u0275ngDeclareFactory",
+    "\u0275\u0275ngDeclareInjectable",
+    "\u0275\u0275ngDeclareInjector",
+    "\u0275\u0275ngDeclareNgModule",
+    "\u0275\u0275ngDeclarePipe",
+];
 function createVueSfcModule(sourcePath, source) {
     const filename = sourcePath;
     const id = `forge-vue-${hashText(sourcePath)}`;
@@ -495,6 +571,9 @@ function extractImportReferences(source) {
     }
     return references;
 }
+function hasBareImport(source, specifier) {
+    return extractImportReferences(source).some((reference) => reference.specifier === specifier);
+}
 function resolveAliasSpecifier(specifier, aliases) {
     for (const [find, replacement] of Object.entries(aliases).sort(([left], [right]) => right.length - left.length || left.localeCompare(right))) {
         if (specifier === find) {
@@ -554,6 +633,7 @@ function resolvePackageImport(packages, specifier) {
     if (packageRecord.entryUrl !== undefined && parsed.subpath === "") {
         return {
             kind: "external",
+            packageRecord,
             url: packageRecord.entryUrl,
         };
     }
@@ -565,6 +645,7 @@ function resolvePackageImport(packages, specifier) {
         (parsed.subpath === normalizedEntry || parsed.subpath === entryWithoutExtension)) {
         return {
             kind: "external",
+            packageRecord,
             url: packageRecord.entryUrl,
         };
     }

package/dist/build-pipeline/diagnostics.d.ts

@@ -5,4 +5,9 @@ export declare function createMissingBuildScriptDiagnostic(): ForgeBuildPipeline
 export declare function createUnsupportedBuildScriptDiagnostic(script: string): ForgeBuildPipelineDiagnostic;
 export declare function createMissingEntryDiagnostic(): ForgeBuildPipelineDiagnostic;
 export declare function createUnresolvedImportDiagnostic(importSpecifier: string, importer: string): ForgeBuildPipelineDiagnostic;
+export declare function createAngularResourceNotFoundDiagnostic(path: string, resourcePath: string): ForgeBuildPipelineDiagnostic;
+export declare function createAngularExternalResourceUnsupportedDiagnostic(path: string, resourcePath: string): ForgeBuildPipelineDiagnostic;
+export declare function createAngularResourceTransformFailedDiagnostic(path: string, cause: unknown): ForgeBuildPipelineDiagnostic;
+export declare function createAngularZoneJsRequiredDiagnostic(path: string): ForgeBuildPipelineDiagnostic;
+export declare function createAngularPartialLinkerRequiredDiagnostic(packageName: string, packageVersion: string, path: string): ForgeBuildPipelineDiagnostic;
 export declare function createViteConfigNotExecutedDiagnostic(path: string): ForgeBuildPipelineDiagnostic;

package/dist/build-pipeline/diagnostics.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createViteConfigNotExecutedDiagnostic = exports.createUnresolvedImportDiagnostic = exports.createMissingEntryDiagnostic = exports.createUnsupportedBuildScriptDiagnostic = exports.createMissingBuildScriptDiagnostic = exports.createBuildCancelledDiagnostic = exports.createEsbuildWorkerTransformDiagnostic = void 0;
+exports.createViteConfigNotExecutedDiagnostic = exports.createAngularPartialLinkerRequiredDiagnostic = exports.createAngularZoneJsRequiredDiagnostic = exports.createAngularResourceTransformFailedDiagnostic = exports.createAngularExternalResourceUnsupportedDiagnostic = exports.createAngularResourceNotFoundDiagnostic = exports.createUnresolvedImportDiagnostic = exports.createMissingEntryDiagnostic = exports.createUnsupportedBuildScriptDiagnostic = exports.createMissingBuildScriptDiagnostic = exports.createBuildCancelledDiagnostic = exports.createEsbuildWorkerTransformDiagnostic = void 0;
 function createEsbuildWorkerTransformDiagnostic(path, cause) {
     return {
         code: "esbuild_worker_transform_failed",
@@ -59,6 +59,57 @@ function createUnresolvedImportDiagnostic(importSpecifier, importer) {
     };
 }
 exports.createUnresolvedImportDiagnostic = createUnresolvedImportDiagnostic;
+function createAngularResourceNotFoundDiagnostic(path, resourcePath) {
+    return {
+        code: "angular_resource_not_found",
+        severity: "error",
+        message: `Angular component resource '${resourcePath}' could not be resolved from ${path}.`,
+        path,
+        resourcePath,
+    };
+}
+exports.createAngularResourceNotFoundDiagnostic = createAngularResourceNotFoundDiagnostic;
+function createAngularExternalResourceUnsupportedDiagnostic(path, resourcePath) {
+    return {
+        code: "angular_external_resource_unsupported",
+        severity: "error",
+        message: `Angular component resource '${resourcePath}' is external and cannot be inlined by Forge.`,
+        path,
+        resourcePath,
+    };
+}
+exports.createAngularExternalResourceUnsupportedDiagnostic = createAngularExternalResourceUnsupportedDiagnostic;
+function createAngularResourceTransformFailedDiagnostic(path, cause) {
+    return {
+        code: "angular_resource_transform_failed",
+        severity: "error",
+        message: "Forge failed to transform Angular component resources.",
+        path,
+        cause,
+    };
+}
+exports.createAngularResourceTransformFailedDiagnostic = createAngularResourceTransformFailedDiagnostic;
+function createAngularZoneJsRequiredDiagnostic(path) {
+    return {
+        code: "angular_zonejs_required",
+        severity: "error",
+        message: "Angular NgModule bootstrap requires zone.js, but Forge could not resolve a compatible package.",
+        path,
+        dependencyName: "zone.js",
+    };
+}
+exports.createAngularZoneJsRequiredDiagnostic = createAngularZoneJsRequiredDiagnostic;
+function createAngularPartialLinkerRequiredDiagnostic(packageName, packageVersion, path) {
+    return {
+        code: "angular_partial_linker_required",
+        severity: "error",
+        message: `Angular package ${packageName}@${packageVersion} contains partial Ivy declarations and needs linked browser ESM or Forge Angular linker support.`,
+        packageName,
+        packageVersion,
+        path,
+    };
+}
+exports.createAngularPartialLinkerRequiredDiagnostic = createAngularPartialLinkerRequiredDiagnostic;
 function createViteConfigNotExecutedDiagnostic(path) {
     return {
         code: "vite_config_not_executed",

package/dist/build-pipeline/index.d.ts

@@ -1,3 +1,3 @@
-export { createBuildCancelledDiagnostic, createEsbuildWorkerTransformDiagnostic, createMissingBuildScriptDiagnostic, createMissingEntryDiagnostic, createUnresolvedImportDiagnostic, createUnsupportedBuildScriptDiagnostic, createViteConfigNotExecutedDiagnostic, } from "./diagnostics";
-export { createBuildPipeline, DefaultBuildPipeline, isSupportedViteBuildScript, } from "./pipeline";
+export { createAngularExternalResourceUnsupportedDiagnostic, createAngularPartialLinkerRequiredDiagnostic, createAngularResourceNotFoundDiagnostic, createAngularResourceTransformFailedDiagnostic, createAngularZoneJsRequiredDiagnostic, createBuildCancelledDiagnostic, createEsbuildWorkerTransformDiagnostic, createMissingEntryDiagnostic, createUnresolvedImportDiagnostic, createViteConfigNotExecutedDiagnostic, } from "./diagnostics";
+export { createBuildPipeline, DefaultBuildPipeline, } from "./pipeline";
 export { BUILD_PIPELINE_CAPABILITY, type ForgeBrowserBundle, type ForgeBrowserBundleManifest, type ForgeBrowserBundleModule, type ForgeBrowserBundleModuleOrigin, type ForgeBuildDiagnostic, type ForgeBuildManifest, type ForgeBuildMode, type ForgeBuildOutputFile, type ForgeBuildPipeline, type ForgeBuildPipelineDiagnostic, type ForgeBuildPipelineDiagnosticCode, type ForgeBuildPipelineOptions, type ForgeBuildRequest, type ForgeBuildResult, type ForgeBuildTiming, type ForgeViteConfigMetadata, } from "./types";

package/dist/build-pipeline/index.js

@@ -1,17 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.BUILD_PIPELINE_CAPABILITY = exports.isSupportedViteBuildScript = exports.DefaultBuildPipeline = exports.createBuildPipeline = exports.createViteConfigNotExecutedDiagnostic = exports.createUnsupportedBuildScriptDiagnostic = exports.createUnresolvedImportDiagnostic = exports.createMissingEntryDiagnostic = exports.createMissingBuildScriptDiagnostic = exports.createEsbuildWorkerTransformDiagnostic = exports.createBuildCancelledDiagnostic = void 0;
+exports.BUILD_PIPELINE_CAPABILITY = exports.DefaultBuildPipeline = exports.createBuildPipeline = exports.createViteConfigNotExecutedDiagnostic = exports.createUnresolvedImportDiagnostic = exports.createMissingEntryDiagnostic = exports.createEsbuildWorkerTransformDiagnostic = exports.createBuildCancelledDiagnostic = exports.createAngularZoneJsRequiredDiagnostic = exports.createAngularResourceTransformFailedDiagnostic = exports.createAngularResourceNotFoundDiagnostic = exports.createAngularPartialLinkerRequiredDiagnostic = exports.createAngularExternalResourceUnsupportedDiagnostic = void 0;
 var diagnostics_1 = require("./diagnostics");
+Object.defineProperty(exports, "createAngularExternalResourceUnsupportedDiagnostic", { enumerable: true, get: function () { return diagnostics_1.createAngularExternalResourceUnsupportedDiagnostic; } });
+Object.defineProperty(exports, "createAngularPartialLinkerRequiredDiagnostic", { enumerable: true, get: function () { return diagnostics_1.createAngularPartialLinkerRequiredDiagnostic; } });
+Object.defineProperty(exports, "createAngularResourceNotFoundDiagnostic", { enumerable: true, get: function () { return diagnostics_1.createAngularResourceNotFoundDiagnostic; } });
+Object.defineProperty(exports, "createAngularResourceTransformFailedDiagnostic", { enumerable: true, get: function () { return diagnostics_1.createAngularResourceTransformFailedDiagnostic; } });
+Object.defineProperty(exports, "createAngularZoneJsRequiredDiagnostic", { enumerable: true, get: function () { return diagnostics_1.createAngularZoneJsRequiredDiagnostic; } });
 Object.defineProperty(exports, "createBuildCancelledDiagnostic", { enumerable: true, get: function () { return diagnostics_1.createBuildCancelledDiagnostic; } });
 Object.defineProperty(exports, "createEsbuildWorkerTransformDiagnostic", { enumerable: true, get: function () { return diagnostics_1.createEsbuildWorkerTransformDiagnostic; } });
-Object.defineProperty(exports, "createMissingBuildScriptDiagnostic", { enumerable: true, get: function () { return diagnostics_1.createMissingBuildScriptDiagnostic; } });
 Object.defineProperty(exports, "createMissingEntryDiagnostic", { enumerable: true, get: function () { return diagnostics_1.createMissingEntryDiagnostic; } });
 Object.defineProperty(exports, "createUnresolvedImportDiagnostic", { enumerable: true, get: function () { return diagnostics_1.createUnresolvedImportDiagnostic; } });
-Object.defineProperty(exports, "createUnsupportedBuildScriptDiagnostic", { enumerable: true, get: function () { return diagnostics_1.createUnsupportedBuildScriptDiagnostic; } });
 Object.defineProperty(exports, "createViteConfigNotExecutedDiagnostic", { enumerable: true, get: function () { return diagnostics_1.createViteConfigNotExecutedDiagnostic; } });
 var pipeline_1 = require("./pipeline");
 Object.defineProperty(exports, "createBuildPipeline", { enumerable: true, get: function () { return pipeline_1.createBuildPipeline; } });
 Object.defineProperty(exports, "DefaultBuildPipeline", { enumerable: true, get: function () { return pipeline_1.DefaultBuildPipeline; } });
-Object.defineProperty(exports, "isSupportedViteBuildScript", { enumerable: true, get: function () { return pipeline_1.isSupportedViteBuildScript; } });
 var types_1 = require("./types");
 Object.defineProperty(exports, "BUILD_PIPELINE_CAPABILITY", { enumerable: true, get: function () { return types_1.BUILD_PIPELINE_CAPABILITY; } });