@ng-prism/core 22.5.0 → 22.7.0-beta.0

package/dist/builder/scanner/service.scanner.js

@@ -0,0 +1,61 @@
+import { readProvision } from './api/angular-decorators.js';
+import { extractServiceApi } from './api/service-api.extractor.js';
+import { readSetupRefs } from './api/setup.reader.js';
+import { createReporters, extractShowcaseConfig } from './component.scanner.js';
+import { describeUnreadableApi } from './showcase-diagnostics.js';
+/**
+ * The `@Showcase` fields that mean something for a service, and for a pipe, which the sidebar and the plugins treat the same way:
+ * what places it in the sidebar, and what a plugin may read.
+ */
+const SERVICE_CONFIG_FIELDS = ['description', 'category', 'categoryOrder', 'componentOrder', 'section', 'sectionOrder', 'tags', 'meta', 'status'];
+/**
+ * Read the services among the showcased classes of an entry point: classes
+ * with `@Injectable` or `@Service`, unless they declare fields only a component
+ * can use. Components are left to {@link scanComponents}.
+ *
+ * Nothing is run and the class is never imported: the service is read from the
+ * source, its API from the declarations, its `setup` from the array literal
+ * the arrow function returns. A service whose API cannot be read is left out
+ * with a notice, so that it does not take the whole scan down.
+ */
+export function scanServices(showcased, checker, { exportIndex, diagnostics, notices }) {
+    const services = [];
+    const { report, notify } = createReporters(diagnostics, notices);
+    for (const { symbol, classDecl, decorator, argument, kind: classKind } of showcased) {
+        if (classKind.kind !== 'service')
+            continue;
+        const className = classDecl.name?.text ?? 'Anonymous';
+        const showcaseConfig = extractShowcaseConfig(decorator, className, report, checker);
+        if (!showcaseConfig || !argument)
+            continue;
+        let api;
+        try {
+            api = extractServiceApi(classDecl, readSetupRefs(argument, className, checker, exportIndex, report), checker, exportIndex);
+        }
+        catch (error) {
+            notify(describeUnreadableApi(className, error, 'service'));
+            continue;
+        }
+        const service = {
+            className,
+            filePath: classDecl.getSourceFile().fileName,
+            showcaseConfig: pickServiceFields(showcaseConfig),
+            provision: readProvision(classKind.decorator, checker),
+            api
+        };
+        const importPath = exportIndex.get(symbol);
+        if (importPath !== undefined)
+            service.importPath = importPath;
+        services.push(service);
+    }
+    return services;
+}
+/** `title` and whichever of the service fields the config sets: a component's `variants`, `bg` and the like mean nothing here. */
+export function pickServiceFields(config) {
+    const picked = { title: config.title };
+    for (const field of SERVICE_CONFIG_FIELDS) {
+        if (config[field] !== undefined)
+            Object.assign(picked, { [field]: config[field] });
+    }
+    return picked;
+}

package/dist/builder/scanner/showcase-diagnostics.d.ts

@@ -1,5 +1,5 @@
 import ts from 'typescript';
-import { type UnevaluableIssue } from './ast-utils.js';
+import { type EvaluationPath, type UnevaluableIssue } from './ast-utils.js';
 import type { UnreadableBase } from './class-hierarchy.js';
 /**
  * Describe one value the scanner had to drop from a `@Showcase` config:
@@ -8,6 +8,21 @@ import type { UnreadableBase } from './class-hierarchy.js';
  * `SguiFileInputComponent › variants[3] "Auto hint" › inputs.maxFileSize — "megabytes(5)" (src/file-input.component.ts:27:22) cannot be evaluated statically and was dropped.`
  */
 export declare function describeUnevaluable(className: string, config: ts.Expression, issue: UnevaluableIssue): string;
+/**
+ * Describe a value of a `@Showcase` config that is valid to the evaluator but not to the scan: which component, where
+ * in the config, what is wrong and where. `path` is read as in {@link describeUnevaluable}, with array indices as
+ * written in the source. The location is the node at `path` when the literal has one, else the whole config.
+ *
+ * `FormFieldComponent › variants[2] "Both" › content — set together with template; template wins and content was dropped (src/form-field.component.ts:31:9)`
+ */
+export declare function describeShowcaseIssue(className: string, config: ts.Expression, path: EvaluationPath, text: string): string;
+/**
+ * Name the places of a `@Showcase` config that something comes from, and where the first of them is written, read as
+ * in {@link describeShowcaseIssue}.
+ *
+ * `variants[0] "Default", variants[3] "Again" (src/form-field.component.ts:20:9)`
+ */
+export declare function describeShowcaseOrigin(config: ts.Expression, paths: readonly EvaluationPath[]): string;
 /**
  * `providers` never reached the manifest: classes, factories and instances
  * cannot be written into static data. One message for the field, not one per
@@ -22,4 +37,48 @@ export declare function describeDeprecatedProviders(className: string, config: t
  * knows which variant values will not reach the component.
  */
 export declare function describeUnreadableBase(className: string, base: UnreadableBase): string;
+/**
+ * A class with `@Injectable` or `@Service` that still declares fields only a
+ * component can use. Shown as a component for now, so nothing is lost, but
+ * the service page will not have these fields, which is why it is said early.
+ */
+export declare function describeLegacyServiceComponent(className: string, fields: string[]): string;
+/**
+ * A class with `@Pipe` that still declares fields only a component can use:
+ * the pipe counterpart of {@link describeLegacyServiceComponent}. A pipe declared
+ * in an NgModule (`standalone: false`) has more to lose, since ng-prism will not
+ * show it at all.
+ */
+export declare function describeLegacyPipeComponent(className: string, fields: string[], standalone: boolean): string;
+/** A pipe declared in an NgModule cannot be called from a template the styleguide builds, so it is not shown. */
+export declare function describePipeNotStandalone(className: string, node: ts.Node): string;
+/**
+ * The name is what a template calls the pipe by; without it the pipe has no
+ * usage to show. It points at the `name` property of the `@Pipe({ … })`
+ * literal if there is one, else at the decorator.
+ */
+export declare function describePipeNameUnreadable(className: string, decorator: ts.Decorator): string;
+/** `setup` lists what configures a service or a pipe; a component has no use for it, and says so instead of silently ignoring it. */
+export declare function describeSetupOnComponent(className: string, node: ts.Node): string;
+/**
+ * {@link describeSetupOnComponent} for a service or pipe that its component-only `fields` still keep a component:
+ * the class has the decorator the generic message names, so it says why that is not enough.
+ */
+export declare function describeSetupOnLegacyComponent(className: string, node: ts.Node, fields: string[]): string;
+/**
+ * The notice for an API the extractor could not read. A notice, not a diagnostic: no `@Showcase` value was dropped,
+ * so strictShowcase does not fail over it. A component keeps its page, which falls back to its inputs and outputs;
+ * a service or a pipe has nothing else to show and is left out.
+ */
+export declare function describeUnreadableApi(className: string, error: unknown, kind: 'component' | 'service' | 'pipe'): string;
+/**
+ * `setup` has to be readable without running anything: an arrow function whose
+ * body is an array literal. Anything else drops the whole field, since there is
+ * no telling which entries it would have listed.
+ */
+export declare function describeInvalidSetup(className: string, node: ts.Node): string;
+/** The styleguide shows where to import a `setup` entry from, which it only knows for what a library entry point exports. */
+export declare function describeSetupEntryNotExported(className: string, index: number, node: ts.Node): string;
+/** A `setup` entry stands for a provider function or an InjectionToken; a class, a plain value or a call is neither. */
+export declare function describeSetupEntryNotSupported(className: string, index: number, node: ts.Node): string;
 //# sourceMappingURL=showcase-diagnostics.d.ts.map

package/dist/builder/scanner/showcase-diagnostics.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"showcase-diagnostics.d.ts","sourceRoot":"","sources":["../../../src/builder/scanner/showcase-diagnostics.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,MAAM,YAAY,CAAC;AAC5B,OAAO,EAA2C,KAAK,gBAAgB,EAA4B,MAAM,gBAAgB,CAAC;AAC1H,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAa3D;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,EAAE,CAAC,UAAU,EAAE,KAAK,EAAE,gBAAgB,GAAG,MAAM,CAY7G;AAED;;;;;;GAMG;AACH,wBAAgB,2BAA2B,CAAC,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,EAAE,CAAC,UAAU,EAAE,KAAK,CAAC,EAAE,EAAE,CAAC,IAAI,GAAG,MAAM,CAO7G;AAED;;;;GAIG;AACH,wBAAgB,sBAAsB,CAAC,SAAS,EAAE,MAAM,EAAE,IAAI,EAAE,cAAc,GAAG,MAAM,CAOtF"}
+{"version":3,"file":"showcase-diagnostics.d.ts","sourceRoot":"","sources":["../../../src/builder/scanner/showcase-diagnostics.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,MAAM,YAAY,CAAC;AAC5B,OAAO,EAAsB,KAAK,cAAc,EAAwB,KAAK,gBAAgB,EAA4B,MAAM,gBAAgB,CAAC;AAChJ,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAa3D;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,EAAE,CAAC,UAAU,EAAE,KAAK,EAAE,gBAAgB,GAAG,MAAM,CAY7G;AAED;;;;;;GAMG;AACH,wBAAgB,qBAAqB,CAAC,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,EAAE,CAAC,UAAU,EAAE,IAAI,EAAE,cAAc,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAE1H;AAED;;;;;GAKG;AACH,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,EAAE,CAAC,UAAU,EAAE,KAAK,EAAE,SAAS,cAAc,EAAE,GAAG,MAAM,CAEtG;AAED;;;;;;GAMG;AACH,wBAAgB,2BAA2B,CAAC,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,EAAE,CAAC,UAAU,EAAE,KAAK,CAAC,EAAE,EAAE,CAAC,IAAI,GAAG,MAAM,CAO7G;AAED;;;;GAIG;AACH,wBAAgB,sBAAsB,CAAC,SAAS,EAAE,MAAM,EAAE,IAAI,EAAE,cAAc,GAAG,MAAM,CAOtF;AAED;;;;GAIG;AACH,wBAAgB,8BAA8B,CAAC,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,MAAM,CAK1F;AAED;;;;;GAKG;AACH,wBAAgB,2BAA2B,CAAC,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,EAAE,UAAU,EAAE,OAAO,GAAG,MAAM,CAM5G;AAED,iHAAiH;AACjH,wBAAgB,yBAAyB,CAAC,SAAS,EAAE,MAAM,EAAE,IAAI,EAAE,EAAE,CAAC,IAAI,GAAG,MAAM,CAElF;AAED;;;;GAIG;AACH,wBAAgB,0BAA0B,CAAC,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,EAAE,CAAC,SAAS,GAAG,MAAM,CAK7F;AAED,qIAAqI;AACrI,wBAAgB,wBAAwB,CAAC,SAAS,EAAE,MAAM,EAAE,IAAI,EAAE,EAAE,CAAC,IAAI,GAAG,MAAM,CAEjF;AAED;;;GAGG;AACH,wBAAgB,8BAA8B,CAAC,SAAS,EAAE,MAAM,EAAE,IAAI,EAAE,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,MAAM,CAEzG;AAED;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,EAAE,IAAI,EAAE,WAAW,GAAG,SAAS,GAAG,MAAM,GAAG,MAAM,CAMvH;AAED;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,SAAS,EAAE,MAAM,EAAE,IAAI,EAAE,EAAE,CAAC,IAAI,GAAG,MAAM,CAK7E;AAED,6HAA6H;AAC7H,wBAAgB,6BAA6B,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,EAAE,CAAC,IAAI,GAAG,MAAM,CAKrG;AAED,wHAAwH;AACxH,wBAAgB,8BAA8B,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,EAAE,CAAC,IAAI,GAAG,MAAM,CAEtG"}

package/dist/builder/scanner/showcase-diagnostics.js

@@ -1,6 +1,6 @@
 import { relative } from 'node:path';
 import ts from 'typescript';
-import { evaluateExpression } from './ast-utils.js';
+import { evaluateExpression, getDecoratorArgument } from './ast-utils.js';
 const MAX_EXCERPT_LENGTH = 60;
 const CAUSES = {
     let: 'is declared with let; only const declarations can be read',
@@ -27,6 +27,25 @@ export function describeUnevaluable(className, config, issue) {
     const cause = issue.cause ? `: ${excerpt(issue.cause.node)} ${CAUSES[issue.cause.kind]}` : '';
     return `${className} › ${where} — "${excerpt(issue.node)}" (${location(issue.node)}) ${consequence}${cause}.`;
 }
+/**
+ * Describe a value of a `@Showcase` config that is valid to the evaluator but not to the scan: which component, where
+ * in the config, what is wrong and where. `path` is read as in {@link describeUnevaluable}, with array indices as
+ * written in the source. The location is the node at `path` when the literal has one, else the whole config.
+ *
+ * `FormFieldComponent › variants[2] "Both" › content — set together with template; template wins and content was dropped (src/form-field.component.ts:31:9)`
+ */
+export function describeShowcaseIssue(className, config, path, text) {
+    return `${className} › ${formatShowcasePath(path, config)} — ${text} (${location(nodeAtPath(config, path) ?? config)})`;
+}
+/**
+ * Name the places of a `@Showcase` config that something comes from, and where the first of them is written, read as
+ * in {@link describeShowcaseIssue}.
+ *
+ * `variants[0] "Default", variants[3] "Again" (src/form-field.component.ts:20:9)`
+ */
+export function describeShowcaseOrigin(config, paths) {
+    return `${paths.map((path) => formatShowcasePath(path, config)).join(', ')} (${location((paths[0] && nodeAtPath(config, paths[0])) ?? config)})`;
+}
 /**
  * `providers` never reached the manifest: classes, factories and instances
  * cannot be written into static data. One message for the field, not one per
@@ -49,14 +68,89 @@ export function describeUnreadableBase(className, base) {
     return (`${className} inherits ${base.inputs.join(', ')} from ${baseName}, which only exists as a declaration (${location(base.classDecl)}); ` +
         `without its source these inputs cannot be read, so they are missing from the manifest and variants cannot set them.`);
 }
-/** A variant is named by its `name` as well as its index, since that is what the styleguide shows. */
+/**
+ * A class with `@Injectable` or `@Service` that still declares fields only a
+ * component can use. Shown as a component for now, so nothing is lost, but
+ * the service page will not have these fields, which is why it is said early.
+ */
+export function describeLegacyServiceComponent(className, fields) {
+    return (`${className} is an @Injectable/@Service with @Showcase and declares ${fields.join(', ')}, so it is still treated as a component. ` +
+        `From 23.0.0 it will be shown as a service and these fields will be dropped; remove them, or move the page to a componentPage.`);
+}
+/**
+ * A class with `@Pipe` that still declares fields only a component can use:
+ * the pipe counterpart of {@link describeLegacyServiceComponent}. A pipe declared
+ * in an NgModule (`standalone: false`) has more to lose, since ng-prism will not
+ * show it at all.
+ */
+export function describeLegacyPipeComponent(className, fields, standalone) {
+    const lead = `${className} is a @Pipe with @Showcase and declares ${fields.join(', ')}, so it is still treated as a component. `;
+    return standalone
+        ? `${lead}From 23.0.0 it will be shown as a pipe and these fields will be dropped; remove them, or move the page to a componentPage.`
+        : `${lead}From 23.0.0 it will be dropped, because ng-prism shows standalone pipes only; make the pipe standalone and remove the fields, or move the page to a componentPage.`;
+}
+/** A pipe declared in an NgModule cannot be called from a template the styleguide builds, so it is not shown. */
+export function describePipeNotStandalone(className, node) {
+    return `${className} › @Pipe (${location(node)}) is declared with standalone: false; ng-prism shows standalone pipes only, so it was dropped.`;
+}
+/**
+ * The name is what a template calls the pipe by; without it the pipe has no
+ * usage to show. It points at the `name` property of the `@Pipe({ … })`
+ * literal if there is one, else at the decorator.
+ */
+export function describePipeNameUnreadable(className, decorator) {
+    const arg = getDecoratorArgument(decorator);
+    const name = arg && ts.isObjectLiteralExpression(arg) ? findProperty(arg, 'name') : undefined;
+    return `${className} › @Pipe name (${location(name ?? decorator)}) cannot be evaluated statically, so the pipe was dropped.`;
+}
+/** `setup` lists what configures a service or a pipe; a component has no use for it, and says so instead of silently ignoring it. */
+export function describeSetupOnComponent(className, node) {
+    return `${className} › setup (${location(node)}) only applies to services and pipes (@Injectable, @Service or @Pipe); it was dropped.`;
+}
+/**
+ * {@link describeSetupOnComponent} for a service or pipe that its component-only `fields` still keep a component:
+ * the class has the decorator the generic message names, so it says why that is not enough.
+ */
+export function describeSetupOnLegacyComponent(className, node, fields) {
+    return `${className} › setup (${location(node)}) was dropped: setup only applies to services and pipes, and the class is still a component because it declares ${fields.join(', ')}.`;
+}
+/**
+ * The notice for an API the extractor could not read. A notice, not a diagnostic: no `@Showcase` value was dropped,
+ * so strictShowcase does not fail over it. A component keeps its page, which falls back to its inputs and outputs;
+ * a service or a pipe has nothing else to show and is left out.
+ */
+export function describeUnreadableApi(className, error, kind) {
+    const reason = error instanceof Error ? error.message : String(error);
+    return kind === 'component'
+        ? `${className}: could not read its API for the API page (${reason}); the page falls back to its inputs and outputs.`
+        : `${className}: could not read its API (${reason}); the ${kind} is left out of the styleguide.`;
+}
+/**
+ * `setup` has to be readable without running anything: an arrow function whose
+ * body is an array literal. Anything else drops the whole field, since there is
+ * no telling which entries it would have listed.
+ */
+export function describeInvalidSetup(className, node) {
+    return (`${className} › setup — "${excerpt(node)}" (${location(node)}) must be an arrow function returning an array literal, ` +
+        `e.g. setup: () => [provideX]; setup was dropped.`);
+}
+/** The styleguide shows where to import a `setup` entry from, which it only knows for what a library entry point exports. */
+export function describeSetupEntryNotExported(className, index, node) {
+    return (`${className} › setup[${index}] — "${excerpt(node)}" (${location(node)}) is not exported from any library entry point, ` +
+        `so the styleguide cannot show where to import it from; it was dropped.`);
+}
+/** A `setup` entry stands for a provider function or an InjectionToken; a class, a plain value or a call is neither. */
+export function describeSetupEntryNotSupported(className, index, node) {
+    return `${className} › setup[${index}] — "${excerpt(node)}" (${location(node)}) is neither a function nor an InjectionToken; it was dropped.`;
+}
+/** A variant or a state is named by its `name` as well as its index, since that is what the styleguide shows. */
 function formatShowcasePath(path, config) {
     const [head, index, ...rest] = path;
-    if (head !== 'variants' || typeof index !== 'number')
+    if ((head !== 'variants' && head !== 'states') || typeof index !== 'number')
         return formatPath(path);
-    const name = variantName(config, index);
-    const variant = name === undefined ? `variants[${index}]` : `variants[${index}] ${JSON.stringify(name)}`;
-    return rest.length === 0 ? variant : `${variant} › ${formatPath(rest)}`;
+    const name = elementName(config, head, index);
+    const element = name === undefined ? `${head}[${index}]` : `${head}[${index}] ${JSON.stringify(name)}`;
+    return rest.length === 0 ? element : `${element} › ${formatPath(rest)}`;
 }
 function formatPath(path) {
     return path
@@ -70,13 +164,32 @@ function formatPath(path) {
         .join('');
 }
 /** Read from the source, because the evaluated array has already lost the elements before the index. */
-function variantName(config, index) {
-    const variants = ts.isObjectLiteralExpression(config) ? findInitializer(config, 'variants') : undefined;
-    const variant = variants && ts.isArrayLiteralExpression(variants) ? variants.elements[index] : undefined;
-    const name = variant && ts.isObjectLiteralExpression(variant) ? findInitializer(variant, 'name') : undefined;
+function elementName(config, key, index) {
+    const elements = ts.isObjectLiteralExpression(config) ? findInitializer(config, key) : undefined;
+    const element = elements && ts.isArrayLiteralExpression(elements) ? elements.elements[index] : undefined;
+    const name = element && ts.isObjectLiteralExpression(element) ? findInitializer(element, 'name') : undefined;
     const value = name && evaluateExpression(name);
     return typeof value === 'string' ? value : undefined;
 }
+/** The property or element the literal has at `path`, or `undefined` as soon as the literal stops spelling the path out, as with a spread or a constant. */
+function nodeAtPath(config, path) {
+    let container = config;
+    let found;
+    for (const segment of path) {
+        const member = typeof segment === 'number'
+            ? ts.isArrayLiteralExpression(container)
+                ? container.elements[segment]
+                : undefined
+            : ts.isObjectLiteralExpression(container)
+                ? findProperty(container, segment)
+                : undefined;
+        if (!member)
+            return undefined;
+        found = member;
+        container = ts.isPropertyAssignment(member) ? member.initializer : member;
+    }
+    return found;
+}
 function findProperty(object, key) {
     return object.properties.find((prop) => prop.name !== undefined && (ts.isIdentifier(prop.name) || ts.isStringLiteral(prop.name)) && prop.name.text === key);
 }

package/dist/builder/scanner/showcase-states.d.ts

@@ -0,0 +1,17 @@
+import type { ShowcaseState } from '../../decorator/showcase.types.js';
+/**
+ * `ShowcaseConfig.states` as the scanner evaluated it, with everything it
+ * cannot use reported. `undefined` when it is no list, or an empty one.
+ *
+ * Every slot of the list survives, because a state is identified by its
+ * position (the URL, the marker and the discovery manifest use it): an
+ * unusable entry becomes a state without pseudo states, which the styleguide
+ * shows as an empty column, instead of shifting the entries behind it.
+ * A state without a usable name is called `State <position>`.
+ *
+ * `unevaluable` holds the source positions of the entries the evaluator could
+ * not read at all. They are missing from `value`, so an empty slot goes back
+ * in at each of them, without a message of its own.
+ */
+export declare function readShowcaseStates(value: unknown, className: string, report: (message: string) => void, unevaluable?: ReadonlySet<number>): ShowcaseState[] | undefined;
+//# sourceMappingURL=showcase-states.d.ts.map

package/dist/builder/scanner/showcase-states.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"showcase-states.d.ts","sourceRoot":"","sources":["../../../src/builder/scanner/showcase-states.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAUvE;;;;;;;;;;;;;GAaG;AACH,wBAAgB,kBAAkB,CAC9B,KAAK,EAAE,OAAO,EACd,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,EACjC,WAAW,GAAE,WAAW,CAAC,MAAM,CAAa,GAC7C,aAAa,EAAE,GAAG,SAAS,CA4C7B"}

package/dist/builder/scanner/showcase-states.js

@@ -0,0 +1,58 @@
+import { describeValue, readPseudoStates } from './pseudo-states.js';
+function isEmptyObject(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value) && Object.keys(value).length === 0;
+}
+/** Stands in for a state the evaluator dropped, which its own diagnostic already explains. */
+const GAP = Symbol('unevaluable state');
+/**
+ * `ShowcaseConfig.states` as the scanner evaluated it, with everything it
+ * cannot use reported. `undefined` when it is no list, or an empty one.
+ *
+ * Every slot of the list survives, because a state is identified by its
+ * position (the URL, the marker and the discovery manifest use it): an
+ * unusable entry becomes a state without pseudo states, which the styleguide
+ * shows as an empty column, instead of shifting the entries behind it.
+ * A state without a usable name is called `State <position>`.
+ *
+ * `unevaluable` holds the source positions of the entries the evaluator could
+ * not read at all. They are missing from `value`, so an empty slot goes back
+ * in at each of them, without a message of its own.
+ */
+export function readShowcaseStates(value, className, report, unevaluable = new Set()) {
+    if (!Array.isArray(value)) {
+        report(`${className} declares invalid states ${describeValue(value)}, expected a list of { name, pseudo }. Skipping.`);
+        return undefined;
+    }
+    const entries = [...value];
+    // Ascending, so that each position is already the one the source gives it once the earlier gaps are back.
+    for (const index of [...unevaluable].sort((a, b) => a - b))
+        entries.splice(index, 0, GAP);
+    if (entries.length === 0)
+        return undefined;
+    const firstIndexOfName = new Map();
+    return entries.map((entry, index) => {
+        const state = typeof entry === 'object' && entry !== null && !Array.isArray(entry) ? entry : undefined;
+        const declaredName = state?.['name'];
+        const hasName = typeof declaredName === 'string' && declaredName.trim() !== '';
+        if (state && !hasName)
+            report(`${className} states[${index}] has no name, expected a non-empty string. Calling it "State ${index + 1}".`);
+        else if (!state && entry !== GAP)
+            report(`${className} states[${index}] is ${describeValue(entry)}, expected { name, pseudo }. Its column stays empty.`);
+        const name = hasName ? declaredName : `State ${index + 1}`;
+        const first = firstIndexOfName.get(name);
+        if (first !== undefined) {
+            report(`${className} state "${name}" repeats the name of states[${first}]; only the first one is used. Its column stays empty.`);
+            return { name, pseudo: {} };
+        }
+        firstIndexOfName.set(name, index);
+        if (!state)
+            return { name, pseudo: {} };
+        const pseudo = state['pseudo'];
+        // `readPseudoStates` reports what it drops, but an empty object has nothing to drop.
+        if (pseudo === undefined || isEmptyObject(pseudo)) {
+            report(`${className} state "${name}" declares no pseudo states. Its column stays empty.`);
+            return { name, pseudo: {} };
+        }
+        return { name, pseudo: readPseudoStates(pseudo, `${className} state "${name}"`, report) ?? {} };
+    });
+}

package/dist/builder/scanner/source-file-cache.d.ts

@@ -0,0 +1,26 @@
+import ts from 'typescript';
+export interface SourceFileCache {
+    /** Pass to `ts.createProgram` together with the previous program. */
+    host: ts.CompilerHost;
+    /** Drop every cached file the given program no longer contains. */
+    prune(program: ts.Program): void;
+}
+/**
+ * A compiler host that hands out the same `SourceFile` for a file that has
+ * not changed since it was last parsed.
+ *
+ * `ts.createProgram(…, oldProgram)` only reuses a file from the old program
+ * when the host returns the identical object. The default host reads and
+ * parses on every call, so without this cache each rebuild re-parses the
+ * whole program, Angular's typings included.
+ *
+ * A file counts as unchanged while its mtime and size are. An edit that keeps
+ * the size and lands within the file system's mtime resolution goes unseen;
+ * APFS and ext4 record nanoseconds, so in practice that does not happen.
+ *
+ * Module resolutions are recomputed on every program. Reusing them would
+ * miss a file created after an import of it had already failed to resolve,
+ * because the importing file itself has not changed.
+ */
+export declare function createSourceFileCache(compilerOptions: ts.CompilerOptions): SourceFileCache;
+//# sourceMappingURL=source-file-cache.d.ts.map

package/dist/builder/scanner/source-file-cache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"source-file-cache.d.ts","sourceRoot":"","sources":["../../../src/builder/scanner/source-file-cache.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,MAAM,YAAY,CAAC;AAE5B,MAAM,WAAW,eAAe;IAC5B,qEAAqE;IACrE,IAAI,EAAE,EAAE,CAAC,YAAY,CAAC;IACtB,mEAAmE;IACnE,KAAK,CAAC,OAAO,EAAE,EAAE,CAAC,OAAO,GAAG,IAAI,CAAC;CACpC;AAOD;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,qBAAqB,CAAC,eAAe,EAAE,EAAE,CAAC,eAAe,GAAG,eAAe,CAmC1F"}

package/dist/builder/scanner/source-file-cache.js

@@ -0,0 +1,60 @@
+import { statSync } from 'fs';
+import ts from 'typescript';
+/**
+ * A compiler host that hands out the same `SourceFile` for a file that has
+ * not changed since it was last parsed.
+ *
+ * `ts.createProgram(…, oldProgram)` only reuses a file from the old program
+ * when the host returns the identical object. The default host reads and
+ * parses on every call, so without this cache each rebuild re-parses the
+ * whole program, Angular's typings included.
+ *
+ * A file counts as unchanged while its mtime and size are. An edit that keeps
+ * the size and lands within the file system's mtime resolution goes unseen;
+ * APFS and ext4 record nanoseconds, so in practice that does not happen.
+ *
+ * Module resolutions are recomputed on every program. Reusing them would
+ * miss a file created after an import of it had already failed to resolve,
+ * because the importing file itself has not changed.
+ */
+export function createSourceFileCache(compilerOptions) {
+    const host = ts.createCompilerHost(compilerOptions);
+    const parse = host.getSourceFile.bind(host);
+    const cache = new Map();
+    host.getSourceFile = (fileName, languageVersionOrOptions, onError, shouldCreateNewSourceFile) => {
+        const stamp = readStamp(fileName);
+        if (stamp === undefined) {
+            cache.delete(fileName);
+            return undefined;
+        }
+        const cached = cache.get(fileName);
+        if (cached?.stamp === stamp && !shouldCreateNewSourceFile)
+            return cached.sourceFile;
+        const sourceFile = parse(fileName, languageVersionOrOptions, onError, shouldCreateNewSourceFile);
+        if (sourceFile)
+            cache.set(fileName, { stamp, sourceFile });
+        else
+            cache.delete(fileName);
+        return sourceFile;
+    };
+    host.hasInvalidatedResolutions = () => true;
+    return {
+        host,
+        prune(program) {
+            const live = new Set(program.getSourceFiles().map((sf) => sf.fileName));
+            for (const fileName of cache.keys()) {
+                if (!live.has(fileName))
+                    cache.delete(fileName);
+            }
+        }
+    };
+}
+function readStamp(fileName) {
+    try {
+        const { mtimeMs, size } = statSync(fileName);
+        return `${mtimeMs}:${size}`;
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/builder/shared/prism-pipeline.d.ts

@@ -11,6 +11,10 @@ export interface PrismPipelineOptions {
 export interface PrismPipelineResult {
     manifestPath: string;
     componentCount: number;
+    /** Services in the manifest: 0 when no plugin shows services, however many the scan found. */
+    serviceCount: number;
+    /** Pipes in the manifest: 0 when no plugin shows pipes, however many the scan found. */
+    pipeCount: number;
     pageCount: number;
     /** True if the manifest file was actually written; false if the existing content was identical. */
     written: boolean;
@@ -19,6 +23,8 @@ export interface PrismPipelineState {
     scanner: Scanner | undefined;
     /** Sorted, joined entry-file paths. Used to detect when the entry set changed between rebuilds. */
     lastEntrySetKey: string | undefined;
+    /** Hints already logged in this builder run, so that `serve` does not repeat them on every rebuild. */
+    hints: Set<string>;
 }
 export declare function createPipelineState(): PrismPipelineState;
 export declare function runPrismPipeline(options: PrismPipelineOptions, context: BuilderContext, state: PrismPipelineState): Promise<PrismPipelineResult>;

package/dist/builder/shared/prism-pipeline.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"prism-pipeline.d.ts","sourceRoot":"","sources":["../../../src/builder/shared/prism-pipeline.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAShE,OAAO,EAAiB,KAAK,OAAO,EAAmB,MAAM,uBAAuB,CAAC;AAErF,MAAM,WAAW,oBAAoB;IACjC,UAAU,EAAE,MAAM,CAAC;IACnB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,YAAY,EAAE,MAAM,CAAC;IACrB,UAAU,EAAE,MAAM,CAAC;IACnB,8FAA8F;IAC9F,QAAQ,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,mBAAmB;IAChC,YAAY,EAAE,MAAM,CAAC;IACrB,cAAc,EAAE,MAAM,CAAC;IACvB,SAAS,EAAE,MAAM,CAAC;IAClB,mGAAmG;IACnG,OAAO,EAAE,OAAO,CAAC;CACpB;AAED,MAAM,WAAW,kBAAkB;IAC/B,OAAO,EAAE,OAAO,GAAG,SAAS,CAAC;IAC7B,mGAAmG;IACnG,eAAe,EAAE,MAAM,GAAG,SAAS,CAAC;CACvC;AAED,wBAAgB,mBAAmB,IAAI,kBAAkB,CAExD;AAED,wBAAsB,gBAAgB,CAAC,OAAO,EAAE,oBAAoB,EAAE,OAAO,EAAE,cAAc,EAAE,KAAK,EAAE,kBAAkB,GAAG,OAAO,CAAC,mBAAmB,CAAC,CAuFtJ"}
+{"version":3,"file":"prism-pipeline.d.ts","sourceRoot":"","sources":["../../../src/builder/shared/prism-pipeline.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAYhE,OAAO,EAAiB,KAAK,OAAO,EAAqC,MAAM,uBAAuB,CAAC;AAEvG,MAAM,WAAW,oBAAoB;IACjC,UAAU,EAAE,MAAM,CAAC;IACnB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,YAAY,EAAE,MAAM,CAAC;IACrB,UAAU,EAAE,MAAM,CAAC;IACnB,8FAA8F;IAC9F,QAAQ,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,mBAAmB;IAChC,YAAY,EAAE,MAAM,CAAC;IACrB,cAAc,EAAE,MAAM,CAAC;IACvB,8FAA8F;IAC9F,YAAY,EAAE,MAAM,CAAC;IACrB,wFAAwF;IACxF,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,mGAAmG;IACnG,OAAO,EAAE,OAAO,CAAC;CACpB;AAED,MAAM,WAAW,kBAAkB;IAC/B,OAAO,EAAE,OAAO,GAAG,SAAS,CAAC;IAC7B,mGAAmG;IACnG,eAAe,EAAE,MAAM,GAAG,SAAS,CAAC;IACpC,uGAAuG;IACvG,KAAK,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;CACtB;AAED,wBAAgB,mBAAmB,IAAI,kBAAkB,CAExD;AAED,wBAAsB,gBAAgB,CAAC,OAAO,EAAE,oBAAoB,EAAE,OAAO,EAAE,cAAc,EAAE,KAAK,EAAE,kBAAkB,GAAG,OAAO,CAAC,mBAAmB,CAAC,CA8ItJ"}