@nf-beta/angular 0.0.1 → 0.0.2

package/src/builders/build/builder.js

@@ -0,0 +1,348 @@
+import * as fs from 'fs';
+import * as mrmime from 'mrmime';
+import * as path from 'path';
+import { buildApplication } from '@angular/build';
+import { buildApplicationInternal, serveWithVite } from '@angular/build/private';
+import { createBuilder, targetFromTargetString, } from '@angular-devkit/architect';
+import { normalizeOptions } from '@angular-devkit/build-angular/src/builders/dev-server/options.js';
+import { buildForFederation, getExternals, loadFederationConfig, logger, setBuildAdapter, setLogLevel, RebuildQueue, AbortedError, } from '@nf-beta/core/build';
+import { createAngularBuildAdapter, setMemResultHandler, } from '../../utils/angular-esbuild-adapter.js';
+import { existsSync, mkdirSync, rmSync } from 'fs';
+import { fstart } from '../../tools/fstart-as-data-url.js';
+import { EsBuildResult, MemResults, NgCliAssetResult } from '../../utils/mem-resuts.js';
+import { getI18nConfig, translateFederationArtefacts } from '../../utils/i18n.js';
+import { RebuildHubs } from '../../utils/rebuild-events.js';
+import { createSharedMappingsPlugin } from '../../utils/shared-mappings-plugin.js';
+import { updateScriptTags } from '../../utils/updateIndexHtml.js';
+import { federationBuildNotifier } from './federation-build-notifier.js';
+const originalWrite = process.stderr.write.bind(process.stderr);
+process.stderr.write = function (chunk, encodingOrCallback, callback) {
+    const str = typeof chunk === 'string' ? chunk : chunk.toString();
+    if (str.includes('vite:import-analysis') && str.includes('es-module-shims.js')) {
+        return true;
+    }
+    if (typeof encodingOrCallback !== 'string') {
+        return originalWrite(chunk, encodingOrCallback);
+    }
+    return originalWrite(chunk, encodingOrCallback, callback);
+};
+function _buildApplication(options, context, pluginsOrExtensions) {
+    let extensions;
+    if (pluginsOrExtensions && Array.isArray(pluginsOrExtensions)) {
+        extensions = {
+            codePlugins: pluginsOrExtensions,
+        };
+    }
+    else {
+        extensions = pluginsOrExtensions;
+    }
+    return buildApplicationInternal(options, context, extensions);
+}
+export async function* runBuilder(nfOptions, context) {
+    let target = targetFromTargetString(nfOptions.target);
+    let targetOptions = (await context.getTargetOptions(target));
+    let builder = await context.getBuilderNameForTarget(target);
+    if (builder === '@angular-devkit/build-angular:browser-esbuild') {
+        logger.info('.: NATIVE FEDERATION - UPDATE NEEDED :.');
+        logger.info('');
+        logger.info("Since version 17.1, Native Federation uses Angular's");
+        logger.info('Application-Builder and its Dev-Server.');
+        logger.info('');
+        logger.info('If you are sill on Angular 17.0.x, please update to');
+        logger.info('Angular 17.1.x or downgrade to Native Federation 17.0.x.');
+        logger.info('');
+        logger.info('For working with Native Federation 17.1.x (recommented), ');
+        logger.info('please update your project config, e.g. in angular.json');
+        logger.info('');
+        logger.info('This command performs the needed update for default configs:');
+        logger.info('');
+        logger.info('\tng g @angular-architects/native-federation:appbuilder');
+        logger.info('');
+        logger.info('You need to run it once per application to migrate');
+        logger.info('Please find more information here: https://shorturl.at/gADJW');
+        return;
+    }
+    /**
+     * Explicitly defined as devServer or if the target contains "serve"
+     */
+    const runServer = typeof nfOptions.devServer !== 'undefined'
+        ? !!nfOptions.devServer
+        : target.target.includes('serve');
+    let options = (await context.validateOptions(runServer
+        ? {
+            ...targetOptions,
+            port: nfOptions.port || targetOptions['port'],
+        }
+        : targetOptions, builder));
+    let serverOptions = null;
+    const write = true;
+    const watch = nfOptions.watch;
+    if (options['buildTarget']) {
+        serverOptions = await normalizeOptions(context, context.target.project, options);
+        target = targetFromTargetString(options['buildTarget']);
+        targetOptions = (await context.getTargetOptions(target));
+        builder = await context.getBuilderNameForTarget(target);
+        options = (await context.validateOptions(targetOptions, builder));
+    }
+    options.watch = watch;
+    if (nfOptions.baseHref) {
+        options.baseHref = nfOptions.baseHref;
+    }
+    if (nfOptions.outputPath) {
+        options.outputPath = nfOptions.outputPath;
+    }
+    const rebuildEvents = new RebuildHubs();
+    const adapter = createAngularBuildAdapter(options, context, rebuildEvents);
+    setBuildAdapter(adapter);
+    setLogLevel(options.verbose ? 'verbose' : 'info');
+    if (!options.outputPath) {
+        options.outputPath = `dist/${context.target.project}`;
+    }
+    const outputPath = options.outputPath;
+    const outputOptions = {
+        browser: 'browser',
+        server: 'server',
+        media: 'media',
+        ...(typeof outputPath === 'string' ? undefined : outputPath),
+        base: typeof outputPath === 'string' ? outputPath : outputPath.base,
+    };
+    const i18n = await getI18nConfig(context);
+    const localeFilter = getLocaleFilter(options, runServer);
+    const sourceLocaleSegment = typeof i18n?.sourceLocale === 'string'
+        ? i18n.sourceLocale
+        : i18n?.sourceLocale?.subPath || i18n?.sourceLocale?.code || '';
+    const browserOutputPath = path.join(outputOptions.base, outputOptions.browser, options.localize ? sourceLocaleSegment : '');
+    const differentDevServerOutputPath = Array.isArray(localeFilter) && localeFilter.length === 1;
+    const devServerOutputPath = !differentDevServerOutputPath
+        ? browserOutputPath
+        : path.join(outputOptions.base, outputOptions.browser, localeFilter[0]);
+    const entryPoint = path.join(path.dirname(options.tsConfig), 'src/main.ts');
+    const fedOptions = {
+        workspaceRoot: context.workspaceRoot,
+        outputPath: browserOutputPath,
+        federationConfig: inferConfigPath(options.tsConfig),
+        tsConfig: options.tsConfig,
+        verbose: options.verbose,
+        watch: false, // options.watch,
+        dev: !!nfOptions.dev,
+        entryPoint,
+        buildNotifications: nfOptions.buildNotifications,
+        cacheExternalArtifacts: nfOptions.cacheExternalArtifacts,
+    };
+    const activateSsr = nfOptions.ssr && !nfOptions.dev;
+    const start = process.hrtime();
+    const config = await loadFederationConfig(fedOptions);
+    logger.measure(start, 'To load the federation config.');
+    const externals = getExternals(config);
+    const plugins = [
+        createSharedMappingsPlugin(config.sharedMappings),
+        {
+            name: 'externals',
+            setup(build) {
+                if (!activateSsr && build.initialOptions.platform !== 'node') {
+                    build.initialOptions.external = externals.filter(e => e !== 'tslib');
+                }
+            },
+        },
+    ];
+    // SSR build fails when externals are provided via the plugin
+    if (activateSsr) {
+        options.externalDependencies = externals;
+    }
+    const isLocalDevelopment = runServer && nfOptions.dev;
+    // Initialize SSE reloader only for local development
+    if (isLocalDevelopment && nfOptions.buildNotifications?.enable) {
+        federationBuildNotifier.initialize(nfOptions.buildNotifications.endpoint);
+    }
+    const middleware = [
+        ...(isLocalDevelopment
+            ? [
+                federationBuildNotifier.createEventMiddleware(req => removeBaseHref(req, options.baseHref)),
+            ]
+            : []),
+        (req, res, next) => {
+            const url = removeBaseHref(req, options.baseHref);
+            const fileName = path.join(fedOptions.workspaceRoot, devServerOutputPath, url);
+            const exists = fs.existsSync(fileName);
+            if (url !== '/' && url !== '' && exists) {
+                const lookup = mrmime.lookup;
+                const mimeType = lookup(path.extname(fileName)) || 'text/javascript';
+                const rawBody = fs.readFileSync(fileName, 'utf-8');
+                // TODO: Evaluate need for debug infos
+                // const body = addDebugInformation(url, rawBody);
+                const body = rawBody;
+                res.writeHead(200, {
+                    'Content-Type': mimeType,
+                    'Access-Control-Allow-Origin': '*',
+                    'Access-Control-Allow-Methods': 'GET, POST, PUT, DELETE',
+                    'Access-Control-Allow-Headers': 'Content-Type',
+                });
+                res.end(body);
+            }
+            else {
+                next();
+            }
+        },
+    ];
+    const memResults = new MemResults();
+    let first = true;
+    let lastResult;
+    if (existsSync(fedOptions.outputPath)) {
+        rmSync(fedOptions.outputPath, { recursive: true });
+    }
+    if (!existsSync(fedOptions.outputPath)) {
+        mkdirSync(fedOptions.outputPath, { recursive: true });
+    }
+    if (!write) {
+        // todo: Hardcoded disabled?
+        setMemResultHandler((outFiles, outDir) => {
+            const fullOutDir = outDir ? path.join(fedOptions.workspaceRoot, outDir) : undefined;
+            memResults.add(outFiles.map(f => new EsBuildResult(f, fullOutDir)));
+        });
+    }
+    let federationResult;
+    try {
+        const start = process.hrtime();
+        federationResult = await buildForFederation(config, fedOptions, externals);
+        logger.measure(start, 'To build the artifacts.');
+    }
+    catch (e) {
+        logger.error(e?.message ?? 'Building the artifacts failed');
+        process.exit(1);
+    }
+    if (activateSsr) {
+        writeFstartScript(fedOptions);
+    }
+    const hasLocales = i18n?.locales && Object.keys(i18n.locales).length > 0;
+    if (hasLocales && localeFilter) {
+        const start = process.hrtime();
+        translateFederationArtefacts(i18n, localeFilter, outputOptions.base, federationResult);
+        logger.measure(start, 'To translate the artifacts.');
+    }
+    options.deleteOutputPath = false;
+    const appBuilderName = '@angular/build:application';
+    const builderRun = runServer
+        ? serveWithVite(serverOptions, appBuilderName, _buildApplication, context, nfOptions.skipHtmlTransform ? {} : { indexHtml: transformIndexHtml(nfOptions) }, {
+            buildPlugins: plugins,
+            middleware,
+        })
+        : buildApplication(options, context, {
+            codePlugins: plugins,
+            indexHtmlTransformer: transformIndexHtml(nfOptions),
+        });
+    const rebuildQueue = new RebuildQueue();
+    try {
+        for await (const output of builderRun) {
+            lastResult = output;
+            if (!write && output['outputFiles']) {
+                memResults.add(output['outputFiles'].map((file) => new EsBuildResult(file)));
+            }
+            if (!write && output['assetFiles']) {
+                memResults.add(output['assetFiles'].map((file) => new NgCliAssetResult(file)));
+            }
+            // if (write && !runServer && !nfOptions.skipHtmlTransform) {
+            //   updateIndexHtml(fedOptions, nfOptions);
+            // }
+            // if (!runServer) {
+            //   yield output;
+            // }
+            if (!first && (nfOptions.dev || watch)) {
+                rebuildQueue
+                    .enqueue(async (signal) => {
+                    if (signal?.aborted) {
+                        throw new AbortedError('Build canceled before starting');
+                    }
+                    await new Promise((resolve, reject) => {
+                        const timeout = setTimeout(resolve, Math.max(10, nfOptions.rebuildDelay));
+                        if (signal) {
+                            const abortHandler = () => {
+                                clearTimeout(timeout);
+                                reject(new AbortedError('[builder] During delay.'));
+                            };
+                            signal.addEventListener('abort', abortHandler, { once: true });
+                        }
+                    });
+                    if (signal?.aborted) {
+                        throw new AbortedError('[builder] Before federation build.');
+                    }
+                    const start = process.hrtime();
+                    federationResult = await buildForFederation(config, fedOptions, externals, {
+                        skipMappingsAndExposed: false,
+                        skipShared: true,
+                        signal,
+                    });
+                    if (signal?.aborted) {
+                        throw new AbortedError('[builder] After federation build.');
+                    }
+                    if (hasLocales && localeFilter) {
+                        translateFederationArtefacts(i18n, localeFilter, outputOptions.base, federationResult);
+                    }
+                    if (signal?.aborted) {
+                        throw new AbortedError('[builder] After federation translations.');
+                    }
+                    logger.info('Done!');
+                    if (isLocalDevelopment) {
+                        federationBuildNotifier.broadcastBuildCompletion();
+                    }
+                    logger.measure(start, 'To rebuild the federation artifacts.');
+                })
+                    .catch(error => {
+                    if (error instanceof AbortedError) {
+                        logger.verbose('Rebuild was canceled. Cancellation point: ' + error?.message);
+                        federationBuildNotifier.broadcastBuildCancellation();
+                    }
+                    else {
+                        logger.error('Federation rebuild failed!');
+                        if (options.verbose)
+                            console.error(error);
+                        if (isLocalDevelopment) {
+                            federationBuildNotifier.broadcastBuildError(error);
+                        }
+                    }
+                });
+            }
+            first = false;
+        }
+    }
+    finally {
+        rebuildQueue.dispose();
+        if (isLocalDevelopment) {
+            federationBuildNotifier.stopEventServer();
+        }
+    }
+    yield lastResult || { success: false };
+}
+function removeBaseHref(req, baseHref) {
+    let url = req.url ?? '';
+    if (baseHref && url.startsWith(baseHref)) {
+        url = url.substr(baseHref.length);
+    }
+    return url;
+}
+function writeFstartScript(fedOptions) {
+    const serverOutpath = path.join(fedOptions.outputPath, '../server');
+    const fstartPath = path.join(serverOutpath, 'fstart.mjs');
+    const buffer = Buffer.from(fstart, 'base64');
+    fs.mkdirSync(serverOutpath, { recursive: true });
+    fs.writeFileSync(fstartPath, buffer, 'utf-8');
+}
+function getLocaleFilter(options, runServer) {
+    let localize = options.localize || false;
+    if (runServer && Array.isArray(localize) && localize.length > 1) {
+        localize = false;
+    }
+    if (runServer && localize === true) {
+        localize = false;
+    }
+    return localize;
+}
+function inferConfigPath(tsConfig) {
+    const relProjectPath = path.dirname(tsConfig);
+    const relConfigPath = path.join(relProjectPath, 'federation.config.js');
+    return relConfigPath;
+}
+function transformIndexHtml(nfOptions) {
+    return (content) => Promise.resolve(updateScriptTags(content, nfOptions));
+}
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export default createBuilder(runBuilder);

package/src/builders/build/federation-build-notifier.d.ts

@@ -0,0 +1,70 @@
+import type { IncomingMessage, ServerResponse } from 'http';
+type NextFunction = (error?: Error) => void;
+type MiddlewareFunction = (req: IncomingMessage, res: ServerResponse, next: NextFunction) => void;
+/**
+ * Manages Server-Sent Events for federation hot reload in local development
+ * Only active when running in development mode with dev server
+ */
+export declare class FederationBuildNotifier {
+    private connections;
+    private cleanupInterval;
+    private isActive;
+    private endpoint;
+    /**
+     * Initializes the SSE reloader for local development
+     */
+    initialize(endpoint: string): void;
+    /**
+     * Creates SSE middleware for federation events
+     */
+    createEventMiddleware(removeBaseHref: (req: IncomingMessage) => string): MiddlewareFunction;
+    /**
+     * Sets up a new SSE connection
+     */
+    private _setupSSEConnection;
+    /**
+     * Removes a connection from the pool
+     */
+    private _removeConnection;
+    /**
+     * Broadcasts an event to all connected clients
+     * Only works in local development mode
+     */
+    private _broadcastEvent;
+    /**
+     * Sends an event to a specific response stream
+     */
+    private _sendEvent;
+    /**
+     * Starts periodic cleanup of dead connections
+     */
+    private startCleanup;
+    /**
+     * Notifies about successful federation rebuild
+     */
+    broadcastBuildCompletion(): void;
+    /**
+     * Notifies about cancellation of a federation rebuild
+     */
+    broadcastBuildCancellation(): void;
+    /**
+     * Notifies about failed federation rebuild
+     */
+    broadcastBuildError(error: unknown): void;
+    /**
+     * Stops cleanup and closes all connections
+     * Should be called when development server stops
+     */
+    stopEventServer(): void;
+    /**
+     * Returns the number of active connections
+     */
+    get activeConnections(): number;
+    /**
+     * Returns whether the reloader is active
+     */
+    get isRunning(): boolean;
+}
+export declare const federationBuildNotifier: FederationBuildNotifier;
+export {};
+//# sourceMappingURL=federation-build-notifier.d.ts.map

package/src/builders/build/federation-build-notifier.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"federation-build-notifier.d.ts","sourceRoot":"","sources":["../../../../src/builders/build/federation-build-notifier.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,MAAM,CAAC;AAkB5D,KAAK,YAAY,GAAG,CAAC,KAAK,CAAC,EAAE,KAAK,KAAK,IAAI,CAAC;AAC5C,KAAK,kBAAkB,GAAG,CAAC,GAAG,EAAE,eAAe,EAAE,GAAG,EAAE,cAAc,EAAE,IAAI,EAAE,YAAY,KAAK,IAAI,CAAC;AAElG;;;GAGG;AACH,qBAAa,uBAAuB;IAClC,OAAO,CAAC,WAAW,CAAuB;IAC1C,OAAO,CAAC,eAAe,CAA+B;IACtD,OAAO,CAAC,QAAQ,CAAS;IACzB,OAAO,CAAC,QAAQ,CAAqB;IAErC;;OAEG;IACI,UAAU,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI;IAYzC;;OAEG;IACI,qBAAqB,CAC1B,cAAc,EAAE,CAAC,GAAG,EAAE,eAAe,KAAK,MAAM,GAC/C,kBAAkB;IAgBrB;;OAEG;IACH,OAAO,CAAC,mBAAmB;IA4B3B;;OAEG;IACH,OAAO,CAAC,iBAAiB;IAUzB;;;OAGG;IACH,OAAO,CAAC,eAAe;IAyBvB;;OAEG;IACH,OAAO,CAAC,UAAU;IAKlB;;OAEG;IACH,OAAO,CAAC,YAAY;IAsBpB;;OAEG;IACI,wBAAwB,IAAI,IAAI;IAOvC;;OAEG;IACI,0BAA0B,IAAI,IAAI;IAOzC;;OAEG;IACI,mBAAmB,CAAC,KAAK,EAAE,OAAO,GAAG,IAAI;IAQhD;;;OAGG;IACI,eAAe,IAAI,IAAI;IAuB9B;;OAEG;IACH,IAAW,iBAAiB,IAAI,MAAM,CAErC;IAED;;OAEG;IACH,IAAW,SAAS,IAAI,OAAO,CAE9B;CACF;AAGD,eAAO,MAAM,uBAAuB,yBAAgC,CAAC"}

package/src/builders/build/federation-build-notifier.js

@@ -0,0 +1,186 @@
+import { BuildNotificationType } from '@nf-beta/runtime';
+import { logger } from '@nf-beta/core/build';
+/**
+ * Manages Server-Sent Events for federation hot reload in local development
+ * Only active when running in development mode with dev server
+ */
+export class FederationBuildNotifier {
+    connections = [];
+    cleanupInterval = null;
+    isActive = false;
+    endpoint;
+    /**
+     * Initializes the SSE reloader for local development
+     */
+    initialize(endpoint) {
+        if (this.isActive) {
+            return;
+        }
+        this.endpoint = endpoint;
+        this.isActive = true;
+        this.startCleanup();
+        logger.info(`[Federation SSE] Local reloader initialized with endpoint ${this.endpoint}`);
+    }
+    /**
+     * Creates SSE middleware for federation events
+     */
+    createEventMiddleware(removeBaseHref) {
+        if (!this.isActive) {
+            return (_req, _res, next) => next();
+        }
+        return (req, res, next) => {
+            const url = removeBaseHref(req);
+            if (url !== this.endpoint) {
+                return next();
+            }
+            this._setupSSEConnection(req, res);
+        };
+    }
+    /**
+     * Sets up a new SSE connection
+     */
+    _setupSSEConnection(req, res) {
+        res.writeHead(200, {
+            'Content-Type': 'text/event-stream',
+            'Cache-Control': 'no-cache',
+            Connection: 'keep-alive',
+            'Access-Control-Allow-Origin': '*',
+            'Access-Control-Allow-Headers': 'Cache-Control',
+        });
+        // Send initial connection event
+        this._sendEvent(res, {
+            type: 'connected',
+            timestamp: Date.now(),
+        });
+        // Store connection
+        const connection = { response: res, request: req };
+        this.connections.push(connection);
+        // Handle disconnection
+        req.on('close', () => this._removeConnection(connection));
+        req.on('error', () => this._removeConnection(connection));
+        logger.info(`[Federation SSE] Client connected. Active connections: ${this.connections.length}`);
+    }
+    /**
+     * Removes a connection from the pool
+     */
+    _removeConnection(connection) {
+        const index = this.connections.indexOf(connection);
+        if (index !== -1) {
+            this.connections.splice(index, 1);
+            logger.info(`[Federation SSE] Client disconnected. Active connections: ${this.connections.length}`);
+        }
+    }
+    /**
+     * Broadcasts an event to all connected clients
+     * Only works in local development mode
+     */
+    _broadcastEvent(event) {
+        if (!this.isActive || this.connections.length === 0) {
+            return;
+        }
+        const deadConnections = [];
+        this.connections.forEach(connection => {
+            try {
+                this._sendEvent(connection.response, event);
+            }
+            catch {
+                deadConnections.push(connection);
+            }
+        });
+        // Remove dead connections
+        deadConnections.forEach(connection => this._removeConnection(connection));
+        if (this.connections.length > 0) {
+            logger.info(`[Federation SSE] Event '${event.type}' broadcast to ${this.connections.length} clients`);
+        }
+    }
+    /**
+     * Sends an event to a specific response stream
+     */
+    _sendEvent(res, event) {
+        const data = JSON.stringify(event);
+        res.write(`data: ${data}\n\n`);
+    }
+    /**
+     * Starts periodic cleanup of dead connections
+     */
+    startCleanup() {
+        if (this.cleanupInterval) {
+            return;
+        }
+        this.cleanupInterval = setInterval(() => {
+            const aliveBefore = this.connections.length;
+            this.connections = this.connections.filter(connection => !connection.response.destroyed &&
+                !connection.request.destroyed &&
+                connection.response.writable);
+            if (this.connections.length !== aliveBefore) {
+                logger.info(`[Federation SSE] Cleaned up ${aliveBefore - this.connections.length} dead connections`);
+            }
+        }, 30000); // Clean every 30 seconds
+    }
+    /**
+     * Notifies about successful federation rebuild
+     */
+    broadcastBuildCompletion() {
+        this._broadcastEvent({
+            type: BuildNotificationType.COMPLETED,
+            timestamp: Date.now(),
+        });
+    }
+    /**
+     * Notifies about cancellation of a federation rebuild
+     */
+    broadcastBuildCancellation() {
+        this._broadcastEvent({
+            type: BuildNotificationType.CANCELLED,
+            timestamp: Date.now(),
+        });
+    }
+    /**
+     * Notifies about failed federation rebuild
+     */
+    broadcastBuildError(error) {
+        this._broadcastEvent({
+            type: BuildNotificationType.ERROR,
+            timestamp: Date.now(),
+            error: error instanceof Error ? error.message : 'Unknown error',
+        });
+    }
+    /**
+     * Stops cleanup and closes all connections
+     * Should be called when development server stops
+     */
+    stopEventServer() {
+        if (!this.isActive) {
+            return;
+        }
+        if (this.cleanupInterval) {
+            clearInterval(this.cleanupInterval);
+            this.cleanupInterval = null;
+        }
+        this.connections.forEach(connection => {
+            try {
+                connection.response.end();
+            }
+            catch {
+                // Connection might already be closed
+            }
+        });
+        this.connections = [];
+        this.isActive = false;
+        logger.info('[Federation SSE] Local reloader disposed');
+    }
+    /**
+     * Returns the number of active connections
+     */
+    get activeConnections() {
+        return this.connections.length;
+    }
+    /**
+     * Returns whether the reloader is active
+     */
+    get isRunning() {
+        return this.isActive;
+    }
+}
+// Singleton instance for local development
+export const federationBuildNotifier = new FederationBuildNotifier();

package/src/builders/build/schema.d.ts

@@ -0,0 +1,21 @@
+import type { JsonObject } from '@angular-devkit/core';
+import type { BuildNotificationOptions } from '@nf-beta/runtime';
+import type { ESMSInitOptions } from 'es-module-shims';
+
+export interface NfBuilderSchema extends JsonObject {
+  target: string;
+  dev: boolean;
+  port: number;
+  open: boolean;
+  rebuildDelay: number;
+  buildNotifications?: BuildNotificationOptions;
+  shell: string;
+  watch: boolean;
+  skipHtmlTransform: boolean;
+  esmsInitOptions: ESMSInitOptions;
+  baseHref?: string;
+  outputPath?: string;
+  ssr: boolean;
+  devServer?: boolean;
+  cacheExternalArtifacts?: boolean;
+} // eslint-disable-line