@blotch/rsbuild-plugin-angular-lynx 0.0.0-stage → 22.2.0

package/dist/index.js.LICENSE.txt

@@ -0,0 +1,7 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.dev/license
+ */

package/dist/is-lynx-unknown-element-message.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Returns true for Angular template diagnostic messages that are expected noise
+ * for Lynx native elements and should not be shown to the user:
+ *
+ * - "is not a known element" — suppressed by sourceFileCache schema injection but may
+ *   still appear for files not in the tsconfig file list
+ * - "isn't a known property of" — Lynx element stubs don't declare @Input() for every
+ *   platform-specific attribute (src, item-key, scroll-orientation, etc.) so Angular
+ *   reports these as unknown property bindings on the stub components; the renderer
+ *   handles them at runtime via setAttribute
+ */
+export declare const isLynxUnknownElementMessage: (text: string | undefined) => boolean;

package/dist/is-lynx-unknown-element-message.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/layers.d.ts

@@ -0,0 +1,12 @@
+import type { RsbuildPluginAPI } from '@lynx-js/rspeedy';
+/**
+ * Webpack layer names for the dual-thread build. Each entry is duplicated
+ * into two webpack entries with different layers — the layer determines which
+ * SWC target (ES2015 vs ES2019) and which thread-specific configuration
+ * (CSS extraction vs ignore, AMD wrapping vs plain) applies to the module.
+ */
+export declare const LAYERS: {
+    BACKGROUND: string;
+    MAIN_THREAD: string;
+};
+export declare const applyLayers: (api: RsbuildPluginAPI) => void;

package/dist/layers.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/loaders/ignore-css-loader.d.ts

@@ -0,0 +1,7 @@
+import type { Rspack } from '@rsbuild/core';
+/**
+ * Must be a regular function expression (not arrow) — webpack invokes loaders
+ * via .call(loaderContext, source), which arrow functions cannot receive.
+ */
+declare const ignoreCssLoader: (this: Rspack.LoaderContext, source: string) => string;
+export default ignoreCssLoader;

package/dist/loaders/ignore-css-loader.js

@@ -0,0 +1,7 @@
+const ignoreCssLoader = function(source) {
+    this.cacheable(true);
+    if (source.includes('___CSS_LOADER_EXPORT___')) return 'export {}';
+    return source;
+};
+const ignore_css_loader = ignoreCssLoader;
+export default ignore_css_loader;

package/dist/loaders/ignore-css-loader.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/loaders/thread-globals-loader.d.ts

@@ -0,0 +1,8 @@
+import type { Rspack } from '@rsbuild/core';
+/**
+ * Prepends `globalThis["__MAIN_THREAD__"]=<value>;` to every module in the layer.
+ * Replaces the BannerPlugin approach — injections happen per-module during
+ * compilation instead of per-chunk after bundling.
+ */
+declare const threadGlobalsLoader: (this: Rspack.LoaderContext, source: string) => string;
+export default threadGlobalsLoader;

package/dist/loaders/thread-globals-loader.js

@@ -0,0 +1,6 @@
+const threadGlobalsLoader = function(source) {
+    const options = this.getOptions();
+    return `globalThis["__MAIN_THREAD__"]=${options.isMainThread};\n${source}`;
+};
+const thread_globals_loader = threadGlobalsLoader;
+export default thread_globals_loader;

package/dist/loaders/thread-globals-loader.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/logger/dev-logger-middleware.d.ts

@@ -0,0 +1,12 @@
+import type { IncomingMessage, ServerResponse } from 'node:http';
+export declare const formatArg: (arg: unknown) => string;
+export declare const getLogFilePath: () => string;
+/**
+ * Creates a connect-style middleware that handles POST /__dev_logs.
+ * Other requests are passed through to the next middleware.
+ */
+/**
+ * Creates a connect-style middleware that handles POST /__dev_logs.
+ * Other requests are passed through to the next middleware.
+ */
+export declare const createDevLoggerMiddleware: () => ((req: IncomingMessage, res: ServerResponse, next: () => void) => void);

package/dist/logger/dev-logger-middleware.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/logger/dev-logger.d.ts

@@ -0,0 +1,2 @@
+import type { RsbuildPluginAPI } from '@lynx-js/rspeedy';
+export declare const applyDevLogger: (api: RsbuildPluginAPI) => void;

package/dist/logger/dev-logger.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/lynx-diagnostics.d.ts

@@ -0,0 +1,38 @@
+export type LynxDiagnosticCategory = 'html-element' | 'structural' | 'css';
+export type LynxDiagnostic = {
+    file: string;
+    message: string;
+    category: LynxDiagnosticCategory;
+};
+/**
+ * Scans Angular AOT-compiled output for HTML elements used in templates.
+ *
+ * Angular's compiler emits ɵɵelementStart(idx, "tag") and ɵɵelement(idx, "tag")
+ * for every template element. We regex-match these to detect HTML element usage
+ * that will silently fall back to <view> at runtime.
+ */
+export declare const scanCompiledOutputForHtmlElements: (fileCache: Map<string, string | Uint8Array>) => LynxDiagnostic[];
+/**
+ * Scans component source files for patterns that are unsupported in Lynx:
+ * - ViewEncapsulation.ShadowDom (silently falls back to None)
+ */
+export declare const scanSourcesForUnsupportedPatterns: (fileNames: readonly string[]) => LynxDiagnostic[];
+/**
+ * Scans the AOT compiled output for structural issues:
+ * - <list-item> used without a <list> parent in the same component
+ *
+ * Uses the same ɵɵelementStart/ɵɵelement pattern as HTML element detection
+ * to identify element usage in compiled templates.
+ */
+export declare const scanCompiledOutputForStructuralIssues: (fileCache: Map<string, string | Uint8Array>) => LynxDiagnostic[];
+/**
+ * Scans component source files for CSS properties not supported in Lynx.
+ *
+ * Extracts inline styles from @Component decorators and resolves external
+ * styleUrls, then checks each property declaration against the unsupported list.
+ */
+export declare const scanSourcesForUnsupportedCss: (fileNames: readonly string[]) => LynxDiagnostic[];
+/**
+ * Logs Lynx-specific diagnostics to the console, grouped by category.
+ */
+export declare const reportLynxDiagnostics: (diagnostics: LynxDiagnostic[]) => void;

package/dist/lynx-diagnostics.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/lynx-process-eval-result-runtime-module.d.ts

@@ -0,0 +1,21 @@
+import type { RuntimeModule, rspack } from '@rspack/core';
+type LynxProcessEvalResultRuntimeModule = new () => RuntimeModule;
+/**
+ * Webpack RuntimeModule that installs async chunk modules into webpack's registry
+ * after Lynx's native runtime evaluates them. This is the final step in the lazy
+ * loading chain:
+ *
+ *   loadComponent() → import() → __webpack_require__.e(chunkId)
+ *   → ensureChunkHandlers.require → lynx.requireModuleAsync(url, callback)
+ *   → native fetches chunk .js, evaluates AMD IIFE → returns {ids, modules}
+ *   → callback fires → externalInstallChunk({ids, modules})
+ *   → module factories registered in __webpack_require__.m
+ *   → import() promise resolves → Angular Router renders the component
+ *
+ * The lynxProcessEvalResult function is called by the native runtime when it has
+ * already fetched and pre-evaluated a lazy bundle. It receives the chunk result
+ * (containing module IDs and factory functions), installs them, then requires
+ * modules in dependency order so side effects execute correctly.
+ */
+export declare const createLynxProcessEvalResultRuntimeModule: (webpack: typeof rspack) => LynxProcessEvalResultRuntimeModule;
+export {};

package/dist/lynx-process-eval-result-runtime-module.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/plugin-angular-lynx.d.ts

@@ -0,0 +1,3 @@
+import type { RsbuildPlugin } from '@lynx-js/rspeedy';
+import { type PluginAngularLynxOptions } from './utils/options.js';
+export declare const pluginAngularLynx: (options?: PluginAngularLynxOptions) => RsbuildPlugin;

package/dist/plugin-angular-lynx.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/polyfills.js

@@ -0,0 +1,122 @@
+if ("u" < typeof AbortController) {
+    class LynxAbortSignal {
+        constructor(){
+            this.aborted = false;
+            this.reason = void 0;
+            this._listeners = [];
+        }
+        addEventListener(type, listener) {
+            if ('abort' === type) this._listeners.push(listener);
+        }
+        removeEventListener(type, listener) {
+            if ('abort' === type) this._listeners = this._listeners.filter((l)=>l !== listener);
+        }
+        dispatchEvent(event) {
+            if ('abort' === event.type) for (const listener of this._listeners.slice())listener(event);
+            return true;
+        }
+        throwIfAborted() {
+            if (this.aborted) throw this.reason;
+        }
+    }
+    globalThis.AbortSignal = LynxAbortSignal;
+    globalThis.AbortController = class {
+        constructor(){
+            this.signal = new LynxAbortSignal();
+        }
+        abort(reason) {
+            if (this.signal.aborted) return;
+            this.signal.aborted = true;
+            if (void 0 === reason) {
+                const err = new Error('This operation was aborted');
+                err.name = 'AbortError';
+                reason = err;
+            }
+            this.signal.reason = reason;
+            this.signal.dispatchEvent({
+                type: 'abort'
+            });
+        }
+    };
+}
+if ('function' != typeof Object.hasOwn) Object.hasOwn = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+if ('function' != typeof Promise.allSettled) Promise.allSettled = (promises)=>Promise.all(Array.from(promises, (p)=>Promise.resolve(p).then((value)=>({
+                status: 'fulfilled',
+                value
+            }), (reason)=>({
+                status: 'rejected',
+                reason
+            }))));
+if ("u" < typeof performance) globalThis.performance = void 0;
+if ("u" < typeof queueMicrotask) {
+    globalThis.queueMicrotaskPromiseCache = Promise.resolve();
+    globalThis.queueMicrotask = (cb)=>globalThis.queueMicrotaskPromiseCache.then(cb);
+}
+if ("u" < typeof Node) try {
+    class LynxNode {
+    }
+    Object.assign(LynxNode, {
+        ELEMENT_NODE: 1,
+        ATTRIBUTE_NODE: 2,
+        TEXT_NODE: 3,
+        CDATA_SECTION_NODE: 4,
+        PROCESSING_INSTRUCTION_NODE: 7,
+        COMMENT_NODE: 8,
+        DOCUMENT_NODE: 9,
+        DOCUMENT_TYPE_NODE: 10,
+        DOCUMENT_FRAGMENT_NODE: 11,
+        DOCUMENT_POSITION_DISCONNECTED: 1,
+        DOCUMENT_POSITION_PRECEDING: 2,
+        DOCUMENT_POSITION_FOLLOWING: 4,
+        DOCUMENT_POSITION_CONTAINS: 8,
+        DOCUMENT_POSITION_CONTAINED_BY: 16,
+        DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC: 32
+    });
+    globalThis.Node = LynxNode;
+} catch  {}
+try {
+    if ("u" < typeof document) globalThis.document = {
+        defaultView: globalThis,
+        querySelector: ()=>null
+    };
+} catch  {}
+try {
+    if ("u" < typeof window) globalThis.window = globalThis;
+} catch  {}
+try {
+    if ("u" < typeof navigator) globalThis.navigator = {
+        userAgent: ''
+    };
+} catch  {}
+try {
+    if (void 0 === globalThis.location) globalThis.location = {
+        href: 'lynx://app/',
+        protocol: 'lynx:',
+        host: 'app',
+        hostname: 'app',
+        port: '',
+        pathname: '/',
+        search: '',
+        hash: '',
+        origin: 'lynx://app',
+        assign: ()=>{},
+        reload: ()=>{},
+        replace: ()=>{},
+        toString: ()=>'lynx://app/'
+    };
+} catch  {}
+try {
+    if (void 0 === globalThis.history) globalThis.history = {
+        length: 1,
+        state: null,
+        scrollRestoration: 'auto',
+        back: ()=>{},
+        forward: ()=>{},
+        go: ()=>{},
+        pushState: ()=>{},
+        replaceState: ()=>{}
+    };
+} catch  {}
+if ('function' != typeof globalThis.addEventListener) globalThis.addEventListener = ()=>{};
+if ('function' != typeof globalThis.removeEventListener) globalThis.removeEventListener = ()=>{};
+export { };

package/dist/seed-compilation-source-files.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Copies pre-transformed SourceFiles into an Angular compilation's own
+ * source-file cache so its compiler host serves them instead of reading the
+ * original files from disk.
+ *
+ * Why this exists: up to Angular 22.1 the cache was handed over through
+ * `AngularHostOptions.sourceFileCache` on `compilation.initialize()`. In 22.2,
+ * `@angular/build` moved ownership of the cache onto the compilation itself
+ * (`TypeScriptCompilation#sourceFiles`, a protected `Map`) and passes it to
+ * `createAngularCompilerHost()` directly, so the host option no longer exists.
+ * Seeding that map before `initialize()` is the equivalent hook.
+ *
+ * Only in-process compilations (`AotCompilation` / `JitCompilation`) own such a
+ * map. `ParallelCompilation` runs the compiler in a worker thread with a cache
+ * that lives in the worker, so there is nothing to seed — the same as before
+ * 22.2, where the worker ignored `hostOptions.sourceFileCache` entirely. Callers
+ * get `false` back in that case so the miss is observable rather than silent.
+ *
+ * The compilation is typed structurally because `sourceFiles` is `protected`
+ * on `@angular/build`'s class and not part of its public surface.
+ */
+export declare const seedCompilationSourceFiles: (compilation: object, sourceFileCache: ReadonlyMap<string, unknown>) => boolean;

package/dist/seed-compilation-source-files.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/split-chunks.d.ts

@@ -0,0 +1,3 @@
+import type { RsbuildPluginAPI } from '@lynx-js/rspeedy';
+import type { PluginAngularLynxOptions } from './utils/options.js';
+export declare const applySplitChunksRule: (api: RsbuildPluginAPI, options: Required<PluginAngularLynxOptions>) => void;

package/dist/split-chunks.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tailwind.d.ts

@@ -0,0 +1,2 @@
+import type { RsbuildPluginAPI } from '@lynx-js/rspeedy';
+export declare const applyTailwind: (api: RsbuildPluginAPI) => void;

package/dist/tailwind.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/transform-module.d.ts

@@ -0,0 +1,31 @@
+import type { ComponentScopeInfo, ComponentStylesEntry } from './component-styles-cache.js';
+/**
+ * Transforms the Angular-compiled JS for a single component module before rspack
+ * bundles it. This is the per-module half of the AngularLynx pipeline, extracted
+ * from angular.ts's `api.transform` hook so it can be unit-tested as a pure
+ * string→string function (no rspack loader context, no compilation cache).
+ *
+ * It applies, in order:
+ *   1. Prepends `import "<scoped.css>"` statements for the component's scoped
+ *      stylesheets (resolved relative to the component file).
+ *   2. Appends the `Component.ɵcmp.id = '<scopeId>'` assignment that ties the CSS
+ *      files (whose filenames carry the same scope ID) to the runtime component.
+ *   3. Runs the worklet ("main thread" directive) transform over the result.
+ *
+ * It deliberately does NOT make the bootstrap entry accept its own hot
+ * updates (`module.hot.accept()`), which an earlier version did. On Lynx the
+ * screen is drawn by the Angular app on the main thread, but webpack HMR only
+ * runs on the background thread: nothing loads the main-thread hot-update
+ * chunk. A self-accepting entry let the background thread apply the update
+ * and re-bootstrap its own copy of the app, so HMR reported success and the
+ * main thread kept rendering the old code until a manual reload. With no
+ * module accepting, the update aborts and the Lynx HMR client
+ * (`@lynx-js/webpack-dev-transport`) falls back to a full `Page.reload`, which
+ * re-runs both threads with the new bundle.
+ */
+export declare const buildTransformedCode: (params: {
+    code: string;
+    resourcePath: string;
+    componentStyles: Pick<ComponentStylesEntry, "imports"> | undefined;
+    scopeInfo: ComponentScopeInfo | undefined;
+}) => string;

package/dist/transform-module.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/utils/angular/angular-config.d.ts

@@ -0,0 +1,3 @@
+import type { RsbuildPluginAPI } from '@lynx-js/rspeedy';
+import type { NormalizedOptions } from './options.js';
+export declare const applyAngularConfig: (api: RsbuildPluginAPI, buildOptions: NormalizedOptions) => void;

package/dist/utils/angular/angular-config.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/utils/angular/component-scope-id.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Generates a deterministic CSS scope ID for ViewEncapsulation.Emulated.
+ * Uses className + file path to ensure uniqueness — two components with the
+ * same class name in different files get different IDs. The 'l' prefix
+ * (for "Lynx") differentiates these from Angular's default 'ng' prefix IDs,
+ * preventing collisions if browser-Angular scope IDs leak into shared code.
+ * This ID appears in:
+ *   - CSS filenames: `...__scoped_l<hash>.css`
+ *   - ɵcmp.id: patched at the end of angular.ts transform
+ *   - _nghost-l<hash> class: added by EmulatedLynxRenderer.selectRootElement()
+ */
+export declare const generateComponentScopeId: (className: string, containingFile: string) => string;

package/dist/utils/angular/component-scope-id.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/utils/angular/component-style-bundler.d.ts

@@ -0,0 +1,19 @@
+import { ComponentStylesheetBundler } from '@angular/build/src/tools/esbuild/angular/component-stylesheets';
+import type { NormalizedOptions } from './options.js';
+/**
+ * Creates an Angular `ComponentStylesheetBundler` configured for the current workspace.
+ *
+ * Angular's AOT compilation extracts component `styles`/`styleUrl` into separate virtual
+ * style files that must be bundled independently. This bundler handles that step — it is
+ * invoked by the Angular compilation pipeline whenever a component references inline or
+ * external styles, producing CSS that is then injected back into the component's JS output.
+ *
+ * Several options available on `ComponentStylesheetBundler` (Sass preprocessor, Tailwind,
+ * PostCSS, symlink preservation, public path) are intentionally left commented out. They are
+ * not yet wired into the plugin's normalized option set and will need to be enabled as the
+ * plugin matures.
+ *
+ * @param options - Normalized Angular build options derived from the workspace's `angular.json`.
+ * @returns A configured `ComponentStylesheetBundler` ready for use in the compilation pipeline.
+ */
+export declare const createComponentStyleBundler: (options: NormalizedOptions) => ComponentStylesheetBundler;

package/dist/utils/angular/component-style-bundler.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/utils/angular/env.d.ts

@@ -0,0 +1,2 @@
+export declare const maxWorkers: number;
+export declare const useTypeChecking: boolean;

package/dist/utils/angular/env.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/utils/angular/find-up.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.dev/license
+ */
+export declare const findUp: (names: string | string[], from: string) => string | null;

package/dist/utils/angular/find-up.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/utils/angular/normalize-cache.d.ts

@@ -0,0 +1,22 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.dev/license
+ */
+export type NormalizedCachedOptions = {
+    /**
+     * Whether disk cache is enabled.
+     */
+    enabled: boolean;
+    /**
+     * Disk cache path. Example: `/.angular/cache/v12.0.0`.
+     */
+    path: string;
+    /**
+     * Disk cache base path. Example: `/.angular/cache`.
+     */
+    basePath: string;
+};
+export declare const normalizeCacheOptions: (projectMetadata: unknown, workspaceRoot: string) => NormalizedCachedOptions;

package/dist/utils/angular/normalize-cache.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/utils/angular/options.d.ts

@@ -0,0 +1,82 @@
+import type { OutputHashing } from '@angular-devkit/build-angular';
+import type { workspaces } from '@angular-devkit/core';
+import type { TargetDefinition } from '@angular-devkit/core/src/workspace/definitions';
+import { type NormalizedCachedOptions } from './normalize-cache.js';
+/**
+ * Normalizes angular.json's `sourceMap` field which accepts two shapes:
+ *
+ *   - Boolean (`true` / `false`) — applies the same setting to scripts, styles,
+ *     hidden, and vendor sourcemaps.
+ *   - Object (`{ scripts, styles, hidden, vendor }`) — fine-grained control
+ *     used by production builds that want script maps but not vendor or
+ *     stylesheet maps for bundle-size reasons.
+ *
+ * Downstream consumers (the JavaScriptTransformer, the rspack devtool option,
+ * and the diagnostic reporters) all expect the object shape, so we expand the
+ * boolean into the equivalent uniform-object form here.
+ */
+export declare const normalizeSourceMaps: (sourceMap: any) => any;
+/**
+ * Normalizes angular.json's `optimization` field which accepts three shapes:
+ *
+ *   - `undefined` / `true` — enable everything (the default for production).
+ *   - `false` — disable everything (typical for dev builds).
+ *   - Object — granular control over scripts/styles/fonts subsections, where
+ *     each subsection can itself be a boolean or a config object.
+ *
+ * The double-nested shape is messy: `{ styles: true }` means "minify styles
+ * with the default config" while `{ styles: { minify: false, inlineCritical: true } }`
+ * means "use these exact style settings". This function flattens both forms
+ * into a single canonical `{ scripts, styles, fonts }` object that all
+ * downstream code can rely on without re-doing the shape check.
+ *
+ * Note: `inlineCritical` is included in the default style config even though
+ * Lynx doesn't have a concept of "above-the-fold critical CSS" — leaving it
+ * mirrored from Angular's default keeps the option surface compatible with
+ * Angular's own builder so users can copy/paste angular.json snippets.
+ */
+export declare const normalizeOptimization: (optimization?: boolean | Record<string, any> | undefined) => any;
+export type NormalizedI18nOptions = {
+    sourceLocale: string;
+    hasDefinedSourceLocale: boolean;
+};
+export type NormalizedOptions = {
+    tsconfig: string;
+    aot: boolean;
+    optimizationOptions: {
+        scripts: boolean;
+        styles: any;
+        fonts: any;
+    };
+    sourcemapOptions: {
+        vendor: any;
+        hidden: any;
+        scripts: any;
+        styles: any;
+    };
+    fileReplacements: Record<string, string> | undefined;
+    polyfills?: string[];
+    index: string;
+    browser: string;
+    advancedOptimizations: boolean;
+    outputPath: string | undefined;
+    workspaceRoot: string;
+    outputNames: {
+        bundles: string;
+        media: string;
+    };
+    cacheOptions: NormalizedCachedOptions;
+    inlineStyleLanguage: string | undefined;
+    outputHashing: OutputHashing;
+    styles: string[];
+    i18n: NormalizedI18nOptions;
+    i18nMissingTranslation: 'error' | 'warning' | 'ignore';
+};
+export declare const readTarget: (project: workspaces.ProjectDefinition, target?: string) => TargetDefinition | undefined;
+export declare const readBuildOptions: (project: workspaces.ProjectDefinition, basePath: string, configurationName?: string) => Promise<NormalizedOptions>;
+/**
+ * Normalizes the `i18n` section from angular.json's project definition.
+ * Angular supports `sourceLocale` as either a string ('en-US') or an object
+ * ({ code: 'en-US' }). We extract the locale code either way.
+ */
+export declare const normalizeI18nOptions: (raw: unknown) => NormalizedI18nOptions;

package/dist/utils/angular/options.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/utils/angular/read-workspace.d.ts

@@ -0,0 +1,7 @@
+import { workspaces } from '@angular-devkit/core';
+export type AngularWorkspace = {
+    workspace: workspaces.WorkspaceDefinition;
+    basePath: string;
+};
+export declare const getAngularWorkspace: () => Promise<AngularWorkspace>;
+export declare const getProjectByCwd: (workspace: workspaces.WorkspaceDefinition, basePath: string) => string | null;

package/dist/utils/angular/read-workspace.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/utils/angular/resolve-pages.d.ts

@@ -0,0 +1,13 @@
+import type { workspaces } from '@angular-devkit/core';
+export type ResolvedPage = {
+    name: string;
+    browser: string;
+};
+/**
+ * Resolves angular.json projects into entry points for multi-page builds.
+ *
+ * When `pages` is `'all'`, every project with `projectType: 'application'` is
+ * included. When it's a `string[]`, only those named projects are used.
+ * Each project's `architect.build.options.browser` field becomes the entry path.
+ */
+export declare const resolvePages: (workspace: workspaces.WorkspaceDefinition, basePath: string, pages: string[] | "all") => ResolvedPage[];

package/dist/utils/angular/resolve-pages.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/utils/inject-lynx-schema.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Injects CUSTOM_ELEMENTS_SCHEMA into every @Component decorator in a TypeScript
+ * source file that doesn't already declare a schema.
+ *
+ * This is applied via the Angular compiler's sourceFileCache before compilation,
+ * so Angular's template type-checker never sees unknown Lynx element errors
+ * (<view>, <text>, <scroll-view>, etc.) without the user having to declare
+ * schemas manually in every component.
+ */
+export declare const injectLynxSchema: (source: string) => string;

package/dist/utils/inject-lynx-schema.test.d.ts

@@ -0,0 +1 @@
+export {};