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

package/dist/builder/manifest/runtime-manifest.generator.js

@@ -1,4 +1,9 @@
+import { VOID_ELEMENTS } from '../../shared/void-elements.js';
+import { compositionClassName, generateCompositionClass } from './composition-wrapper.generator.js';
 import { parseHostString } from './host-parser.js';
+import { localName, ManifestImports } from './manifest-imports.js';
+import { firstSelectorAttribute, selectorElement } from './selector-element.js';
+import { escapeTemplateLiteral } from './template-literal.js';
 function inputTypeAnnotation(input) {
     if (input.type === 'union' && input.values) {
         return input.values.map((v) => `'${v}'`).join(' | ');
@@ -28,50 +33,82 @@ function formatInputDeclaration(input) {
     }
     return `input(${def})`;
 }
-function directiveSelector(selector) {
-    const match = selector.match(/^\[([^\]]+)]$/);
-    return match ? match[1] : selector;
-}
 function isBindableInput(input) {
     if (input.type === 'string' || input.type === 'number' || input.type === 'boolean' || input.type === 'union') {
         return true;
     }
     return input.defaultValue !== undefined;
 }
-function generateWrapperClass(comp) {
+/** The class an object host renders, or `undefined` when it names none: a plain-JS config can leave `import` out, which the types would have caught. */
+function objectHostImport(host) {
+    const { import: hostImport } = host;
+    return hostImport?.name && hostImport.from ? hostImport : undefined;
+}
+function hasContent(content) {
+    return typeof content === 'string' ? content !== '' : content !== undefined && Object.keys(content).length > 0;
+}
+/** Every variant renders in the composition wrapper: it is the component's `type`, and nothing renders through `__PrismHost`. */
+function isFullyComposed(comp) {
+    const variantCases = comp.composition?.variantCases;
+    return variantCases !== undefined && variantCases.length > 0 && variantCases.every((index) => index >= 0);
+}
+/** The class an object host renders, `undefined` for a directive without one or one whose variants are all composed. */
+function hostWrapperImport(comp) {
+    const host = comp.showcaseConfig.host;
+    return comp.componentMeta.isDirective && !isFullyComposed(comp) && host && typeof host === 'object' && !('template' in host) ? objectHostImport(host) : undefined;
+}
+function generateWrapperClass(comp, warn, localNames) {
     const wrapperName = `${comp.className}__PrismHost`;
     const host = comp.showcaseConfig.host;
-    const directiveAttr = directiveSelector(comp.componentMeta.selector);
+    const selector = comp.componentMeta.selector;
     const bindableInputs = comp.inputs.filter(isBindableInput);
-    let tag;
-    let attrs;
-    let importsArray;
+    // `undefined` without a host: the element then comes from the directive's selector.
+    let hostTag;
+    let attrs = '';
+    let importsArray = `[${comp.className}]`;
     let hostContentDefault = '';
     if (typeof host === 'string') {
         const parsed = parseHostString(host);
-        tag = parsed?.tag ?? 'div';
+        hostTag = parsed?.tag ?? 'div';
         attrs = parsed?.attrs ? ` ${parsed.attrs}` : '';
         hostContentDefault = parsed?.content ?? '';
-        importsArray = `[${comp.className}]`;
     }
-    else if (host && typeof host === 'object') {
-        const hostObj = host;
-        tag = hostObj.selector;
-        const staticInputs = Object.entries(hostObj.inputs ?? {})
-            .map(([k, v]) => ` ${k}="${String(v)}"`)
-            .join('');
-        attrs = staticInputs;
-        importsArray = `[${comp.className}, ${hostObj.import.name}]`;
+    else if (host && typeof host === 'object' && !('template' in host)) {
+        const hostImport = objectHostImport(host);
+        if (hostImport) {
+            hostTag = host.selector;
+            attrs = Object.entries(host.inputs ?? {})
+                .map(([k, v]) => ` ${k}="${String(v)}"`)
+                .join('');
+            importsArray = `[${comp.className}, ${localName(localNames, hostImport.from, hostImport.name)}]`;
+        }
+        else {
+            warn(`${comp.className}: the host names no class to import (host.import), so it renders as <div>.`);
+            hostTag = 'div';
+        }
     }
-    else {
-        tag = 'div';
-        attrs = '';
-        importsArray = `[${comp.className}]`;
+    const element = selectorElement(selector, hostTag);
+    const tag = element?.tag ?? hostTag ?? 'div';
+    if (!element) {
+        warn(`${comp.className}: no part of the selector "${selector}" fits the host <${tag}>, so only its first attribute is set.`);
     }
+    const selectorAttributes = element ? element.attributes : firstSelectorAttribute(selector);
     // The wrapper declares its inputs and outputs under the member names and binds the directive's public ones.
     const inputBindings = bindableInputs.map((i) => ` [${i.alias ?? i.name}]="${i.name}()"`).join('');
     const outputBindings = comp.outputs.map((o) => ` (${o.alias ?? o.name})="${o.name}.emit($event)"`).join('');
-    const template = `<${tag}${attrs} ${directiveAttr}${inputBindings}${outputBindings}>{{ __prismContent__() }}</${tag}>`;
+    const opening = `<${tag}${attrs}${selectorAttributes ? ` ${selectorAttributes}` : ''}${inputBindings}${outputBindings}`;
+    let template;
+    if (VOID_ELEMENTS.has(tag.toLowerCase())) {
+        // A void element has no end tag and no content: Angular rejects `<input></input>` as well as `<input>{{ ... }}`.
+        template = `${opening} />`;
+        if (hasContent(hostContentDefault) || comp.showcaseConfig.variants?.some((v) => hasContent(v.content))) {
+            warn(`${comp.className}: <${tag}> is a void element and takes no content, so the content of the host and of the variants is not rendered.`);
+        }
+    }
+    else {
+        template = `${opening}>{{ __prismContent__() }}</${tag}>`;
+    }
+    // The runtime sets `__prismContent__` on every directive, void host or not, so the wrapper declares it either way.
     const members = [];
     for (const i of bindableInputs) {
         members.push(`  ${i.name} = ${formatInputDeclaration(i)};`);
@@ -80,56 +117,62 @@ function generateWrapperClass(comp) {
         members.push(`  ${o.name} = output();`);
     }
     members.push(`  __prismContent__ = input(${JSON.stringify(hostContentDefault)});`);
-    const lines = [`@Component({`, `  standalone: true,`, `  imports: ${importsArray},`, `  template: \`${template}\`,`, `})`, `class ${wrapperName} {`, ...members, `}`];
+    const lines = [
+        `@Component({`,
+        `  standalone: true,`,
+        `  imports: ${importsArray},`,
+        `  template: \`${escapeTemplateLiteral(template)}\`,`,
+        `})`,
+        `class ${wrapperName} {`,
+        ...members,
+        `}`
+    ];
     return lines.join('\n');
 }
-function groupComponentsByImportPath(components, fallbackImportPath) {
-    const groups = new Map();
+/**
+ * The classes the manifest imports. The showcased components come first, each by its own name, then the classes of
+ * the host wrappers and of the composition wrappers, which take an alias where another class has the name.
+ */
+function collectImports(components, libraryImportPath) {
+    // What the module declares or imports besides the classes: no class may take these identifiers.
+    const imports = new ManifestImports(['Component', 'computed', 'input', 'output', 'RuntimeManifest', 'PRISM_RUNTIME_MANIFEST']);
     for (const comp of components) {
-        const path = comp.importPath ?? fallbackImportPath;
-        const list = groups.get(path);
-        if (list) {
-            list.push(comp.className);
-        }
-        else {
-            groups.set(path, [comp.className]);
+        imports.keep(comp.importPath ?? libraryImportPath, comp.className);
+    }
+    for (const comp of components) {
+        const hostImport = hostWrapperImport(comp);
+        if (hostImport)
+            imports.local(hostImport.from, hostImport.name);
+    }
+    for (const comp of components) {
+        for (const { from, name } of comp.composition?.imports ?? []) {
+            imports.local(from, name);
         }
     }
-    return groups;
+    return imports;
 }
+const defaultWarn = (message) => console.warn(`⚠ ng-prism: ${message}`);
 export function generateRuntimeManifest(options) {
-    const { components, libraryImportPath, pages, meta } = options;
+    const { components, services, pipes, libraryImportPath, pages, meta, warn = defaultWarn } = options;
     const directives = components.filter((c) => c.componentMeta.isDirective);
-    const hasDirectives = directives.length > 0;
+    const hostWrapped = directives.filter((c) => !isFullyComposed(c));
+    const composed = components.filter((c) => c.composition);
+    const hasWrappers = directives.length > 0 || composed.length > 0;
     const lines = ['// AUTO-GENERATED by ng-prism. Do not edit!', "import type { RuntimeManifest } from '@ng-prism/core/plugin';"];
-    if (hasDirectives) {
-        lines.push("import { Component, input, output } from '@angular/core';");
-    }
-    if (components.length > 0) {
-        const groups = groupComponentsByImportPath(components, libraryImportPath);
-        for (const comp of directives) {
-            const host = comp.showcaseConfig.host;
-            if (host && typeof host === 'object' && 'import' in host) {
-                const hostObj = host;
-                const existing = groups.get(hostObj.import.from);
-                if (existing) {
-                    if (!existing.includes(hostObj.import.name)) {
-                        existing.push(hostObj.import.name);
-                    }
-                }
-                else {
-                    groups.set(hostObj.import.from, [hostObj.import.name]);
-                }
-            }
-        }
-        for (const [path, classNames] of groups) {
-            lines.push(`import { ${classNames.join(', ')} } from '${path}';`);
-        }
+    if (hasWrappers) {
+        lines.push(`import { ${['Component', ...(composed.length > 0 ? ['computed'] : []), 'input', 'output'].join(', ')} } from '@angular/core';`);
     }
-    if (hasDirectives) {
+    const imports = collectImports(components, libraryImportPath);
+    const localNames = imports.names();
+    lines.push(...imports.lines());
+    if (hasWrappers) {
         lines.push('');
-        for (const comp of directives) {
-            lines.push(generateWrapperClass(comp));
+        for (const comp of hostWrapped) {
+            lines.push(generateWrapperClass(comp, warn, localNames));
+            lines.push('');
+        }
+        for (const comp of composed) {
+            lines.push(generateCompositionClass(comp, comp.composition, localNames));
             lines.push('');
         }
     }
@@ -137,13 +180,18 @@ export function generateRuntimeManifest(options) {
     lines.push('export const PRISM_RUNTIME_MANIFEST: RuntimeManifest = {');
     lines.push('  components: [');
     for (const comp of components) {
-        const typeName = comp.componentMeta.isDirective ? `${comp.className}__PrismHost` : comp.className;
+        const wrapperName = comp.composition ? compositionClassName(comp.className) : undefined;
+        const typeName = isFullyComposed(comp) ? wrapperName : comp.componentMeta.isDirective ? `${comp.className}__PrismHost` : comp.className;
         lines.push('    {');
         lines.push(`      type: ${typeName},`);
+        if (wrapperName)
+            lines.push(`      composition: ${wrapperName},`);
         lines.push(`      meta: ${formatMeta(comp, 6)},`);
         lines.push('    },');
     }
     lines.push('  ],');
+    pushDataEntries(lines, 'services', services);
+    pushDataEntries(lines, 'pipes', pipes);
     if (pages && pages.length > 0) {
         lines.push(`  pages: ${JSON.stringify(pages, null, 2)
             .split('\n')
@@ -161,6 +209,18 @@ export function generateRuntimeManifest(options) {
     lines.push('');
     return lines.join('\n');
 }
+/** A service or a pipe is `{ meta }` and nothing else: the styleguide never imports its class. Writes no line when there is none. */
+function pushDataEntries(lines, key, items) {
+    if (!items || items.length === 0)
+        return;
+    lines.push(`  ${key}: [`);
+    for (const item of items) {
+        lines.push('    {');
+        lines.push(`      meta: ${formatObject(item, 6)},`);
+        lines.push('    },');
+    }
+    lines.push('  ],');
+}
 function json(value) {
     return JSON.stringify(value);
 }
@@ -176,11 +236,22 @@ function formatMeta(comp, baseIndent) {
     const lines = [
         `${indent(inner)}className: ${json(comp.className)},`,
         `${indent(inner)}filePath: ${json(comp.filePath)},`,
+        // The entry point the class is imported from; a plugin's API page names it, e.g. in a usage snippet.
+        ...(comp.importPath ? [`${indent(inner)}importPath: ${json(comp.importPath)},`] : []),
         `${indent(inner)}showcaseConfig: ${formatObject(comp.showcaseConfig, inner)},`,
         `${indent(inner)}inputs: ${formatArray(comp.inputs, inner)},`,
         `${indent(inner)}outputs: ${formatArray(comp.outputs, inner)},`,
         `${indent(inner)}componentMeta: ${formatObject(comp.componentMeta, inner)},`
     ];
+    if (comp.api) {
+        lines.push(`${indent(inner)}api: ${formatObject(comp.api, inner)},`);
+    }
+    if (comp.composition) {
+        // Without `origin`, which only the comments of the generated code use. `imports` stays: a plugin's usage example names them.
+        const { variantCases, cases, imports } = comp.composition;
+        const data = { variantCases, cases: cases.map(({ template, unbound }) => ({ template, unbound })), imports };
+        lines.push(`${indent(inner)}composition: ${formatObject(data, inner)},`);
+    }
     if (comp.meta && Object.keys(comp.meta).length > 0) {
         lines.push(`${indent(inner)}meta: ${formatObject(comp.meta, inner)},`);
     }

package/dist/builder/manifest/selector-element.d.ts

@@ -0,0 +1,16 @@
+export interface SelectorElement {
+    tag: string;
+    /** The attributes (`name` or `name="value"`) and the classes (`class="a b"`) of the selector part, separated by a space. */
+    attributes: string;
+}
+/**
+ * The element and the attributes a directive's selector asks for, to render the directive on a host element.
+ *
+ * Of a selector list it takes the first part whose element is `tag` or missing; without a `tag`, the first part
+ * and its element, or `div` when it names none. `:not()` is ignored. `null` when no part fits `tag`, or when the
+ * selector does not parse.
+ */
+export declare function selectorElement(selector: string, tag?: string): SelectorElement | null;
+/** The first attribute of the first part of `selector`, as far as there is one: the least that makes a directive apply when its selector fits no host. */
+export declare function firstSelectorAttribute(selector: string): string;
+//# sourceMappingURL=selector-element.d.ts.map

package/dist/builder/manifest/selector-element.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"selector-element.d.ts","sourceRoot":"","sources":["../../../src/builder/manifest/selector-element.ts"],"names":[],"mappings":"AAEA,MAAM,WAAW,eAAe;IAC5B,GAAG,EAAE,MAAM,CAAC;IACZ,4HAA4H;IAC5H,UAAU,EAAE,MAAM,CAAC;CACtB;AAgCD;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,QAAQ,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM,GAAG,eAAe,GAAG,IAAI,CAMtF;AAED,0JAA0J;AAC1J,wBAAgB,sBAAsB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAI/D"}

package/dist/builder/manifest/selector-element.js

@@ -0,0 +1,46 @@
+import { CssSelector } from '@angular/compiler';
+/** The parts of a selector list; a selector that Angular cannot parse has none. */
+function selectorParts(selector) {
+    try {
+        return CssSelector.parse(selector);
+    }
+    catch {
+        return [];
+    }
+}
+/** `*` and a missing element both fit any tag. */
+function elementOf(part) {
+    return part.element && part.element !== '*' ? part.element : null;
+}
+/** The attributes of a part, then its classes as one `class` attribute. */
+function attributeList(part) {
+    const attributes = [];
+    // `attrs` is a flat list of name and value pairs; an attribute without a value has ''.
+    for (let i = 0; i < part.attrs.length; i += 2) {
+        const [name, value] = [part.attrs[i], part.attrs[i + 1]];
+        attributes.push(value ? `${name}="${value.replace(/"/g, '&quot;')}"` : name);
+    }
+    if (part.classNames.length > 0) {
+        attributes.push(`class="${part.classNames.join(' ')}"`);
+    }
+    return attributes;
+}
+/**
+ * The element and the attributes a directive's selector asks for, to render the directive on a host element.
+ *
+ * Of a selector list it takes the first part whose element is `tag` or missing; without a `tag`, the first part
+ * and its element, or `div` when it names none. `:not()` is ignored. `null` when no part fits `tag`, or when the
+ * selector does not parse.
+ */
+export function selectorElement(selector, tag) {
+    const parts = selectorParts(selector);
+    const part = tag === undefined ? parts[0] : parts.find((candidate) => (elementOf(candidate) ?? tag) === tag);
+    if (!part)
+        return null;
+    return { tag: tag ?? elementOf(part) ?? 'div', attributes: attributeList(part).join(' ') };
+}
+/** The first attribute of the first part of `selector`, as far as there is one: the least that makes a directive apply when its selector fits no host. */
+export function firstSelectorAttribute(selector) {
+    const part = selectorParts(selector)[0];
+    return (part && attributeList(part)[0]) || '';
+}

package/dist/builder/manifest/template-literal.d.ts

@@ -0,0 +1,3 @@
+/** Makes `text` safe inside a generated template literal: a backslash, a backtick or `${` in it would end the literal or start an expression. */
+export declare function escapeTemplateLiteral(text: string): string;
+//# sourceMappingURL=template-literal.d.ts.map

package/dist/builder/manifest/template-literal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"template-literal.d.ts","sourceRoot":"","sources":["../../../src/builder/manifest/template-literal.ts"],"names":[],"mappings":"AAAA,iJAAiJ;AACjJ,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAE1D"}

package/dist/builder/manifest/template-literal.js

@@ -0,0 +1,4 @@
+/** Makes `text` safe inside a generated template literal: a backslash, a backtick or `${` in it would end the literal or start an expression. */
+export function escapeTemplateLiteral(text) {
+    return text.replace(/\\/g, '\\\\').replace(/`/g, '\\`').replace(/\$\{/g, '\\${');
+}

package/dist/builder/plugin-runner/plugin-runner.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"plugin-runner.d.ts","sourceRoot":"","sources":["../../../src/builder/plugin-runner/plugin-runner.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAE,aAAa,EAAoB,MAAM,8BAA8B,CAAC;AAgBnG,wBAAsB,cAAc,CAAC,QAAQ,EAAE,aAAa,EAAE,OAAO,EAAE,aAAa,EAAE,GAAG,OAAO,CAAC,aAAa,CAAC,CA4D9G"}
+{"version":3,"file":"plugin-runner.d.ts","sourceRoot":"","sources":["../../../src/builder/plugin-runner/plugin-runner.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,8BAA8B,CAAC;AA0DjF,wBAAsB,cAAc,CAAC,QAAQ,EAAE,aAAa,EAAE,OAAO,EAAE,aAAa,EAAE,GAAG,OAAO,CAAC,aAAa,CAAC,CAiC9G"}

package/dist/builder/plugin-runner/plugin-runner.js

@@ -9,44 +9,47 @@ function wrapPluginError(plugin, hook, target, err) {
     }
     return wrapped;
 }
-export async function runPluginHooks(manifest, plugins) {
-    const components = [...manifest.components];
-    for (let i = 0; i < components.length; i++) {
-        let current = components[i];
+/**
+ * Runs a per-item hook over every item: each item goes through all plugins in
+ * turn, and a plugin that returns a value replaces the item for the next one.
+ */
+async function runItemHook(items, plugins, hook, label) {
+    const done = [];
+    for (const item of items) {
+        let current = item;
         for (const plugin of plugins) {
-            if (plugin.onComponentScanned) {
+            const run = plugin[hook];
+            if (run) {
                 try {
-                    const result = await plugin.onComponentScanned(current);
+                    const result = await run.call(plugin, current);
                     if (result) {
                         current = result;
                     }
                 }
                 catch (err) {
-                    throw wrapPluginError(plugin, 'onComponentScanned', `component "${current.className}"`, err);
+                    throw wrapPluginError(plugin, hook, label(current), err);
                 }
             }
         }
-        components[i] = current;
+        done.push(current);
     }
-    const pages = [...(manifest.pages ?? [])];
-    for (let i = 0; i < pages.length; i++) {
-        let current = pages[i];
-        for (const plugin of plugins) {
-            if (plugin.onPageScanned) {
-                try {
-                    const result = await plugin.onPageScanned(current);
-                    if (result) {
-                        current = result;
-                    }
-                }
-                catch (err) {
-                    throw wrapPluginError(plugin, 'onPageScanned', `page "${current.title}"`, err);
-                }
-            }
-        }
-        pages[i] = current;
+    return done;
+}
+export async function runPluginHooks(manifest, plugins) {
+    const components = await runItemHook(manifest.components, plugins, 'onComponentScanned', (component) => `component "${component.className}"`);
+    const services = await runItemHook(manifest.services ?? [], plugins, 'onServiceScanned', (service) => `service "${service.className}"`);
+    const pipes = await runItemHook(manifest.pipes ?? [], plugins, 'onPipeScanned', (pipe) => `pipe "${pipe.className}"`);
+    const pages = await runItemHook(manifest.pages ?? [], plugins, 'onPageScanned', (page) => `page "${page.title}"`);
+    let result = { components, pages };
+    if (manifest.services) {
+        result.services = services;
+    }
+    if (manifest.pipes) {
+        result.pipes = pipes;
+    }
+    if (manifest.meta) {
+        result.meta = manifest.meta;
     }
-    let result = manifest.meta ? { components, pages, meta: manifest.meta } : { components, pages };
     for (const plugin of plugins) {
         if (plugin.onManifestReady) {
             try {

package/dist/builder/scanner/api/angular-decorators.d.ts

@@ -0,0 +1,84 @@
+import ts from 'typescript';
+import type { ServiceProvision } from '../../../plugin/service.types.js';
+export type ShowcaseClassKind = {
+    kind: 'component';
+}
+/** `decorator` is the `@Injectable` or `@Service` that makes it one. */
+ | {
+    kind: 'service';
+    decorator: ts.Decorator;
+}
+/** `decorator` is the `@Pipe` that makes it one; whether the pipe is shown is for the pipe scan to decide. */
+ | {
+    kind: 'pipe';
+    decorator: ts.Decorator;
+}
+/**
+ * An `@Injectable`, `@Service` or `@Pipe` that still declares component-only `fields`, so it stays a component for now.
+ * `source` says which decorator would make it a service or a pipe; `standalone: false` only for a pipe declared in an NgModule.
+ */
+ | {
+    kind: 'legacy-component';
+    fields: string[];
+    source: 'injectable' | 'pipe';
+    standalone?: false;
+};
+/** What the `@Pipe` metadata says, as far as the source can be read. */
+export interface PipeOptions {
+    /** Missing when the source does not give it as a string constant: the pipe cannot be shown without its name. */
+    name?: string;
+    /** `true` when the metadata does not say, missing when it says something the scan cannot read. */
+    pure?: boolean;
+    /** Only `false` when the metadata statically says `standalone: false`; Angular's default is `true`. */
+    standalone: boolean;
+}
+type AngularCoreDecoratorName = 'Injectable' | 'Service' | 'Component' | 'Directive' | 'Pipe';
+/**
+ * {@link findDecorator} for an Angular decorator, found by the name it has in
+ * `@angular/core` rather than in the file: `import { Injectable as Service }`
+ * makes `@Service` Angular's `Injectable`, and `import * as ng` makes
+ * `@ng.Pipe` its `Pipe`. A `@Service` from a dependency-injection package of
+ * another name has nothing to do with Angular's.
+ *
+ * The scanner never imports `Service` itself, since Angular 20 has none: the
+ * decorator is recognised in the source alone.
+ */
+export declare function findAngularCoreDecorator(classDecl: ts.ClassDeclaration, name: AngularCoreDecoratorName, checker: ts.TypeChecker): ts.Decorator | undefined;
+/**
+ * Tell a service or a pipe from a component. They all carry `@Showcase`, and
+ * the only thing that tells them apart is the Angular decorator beside it.
+ *
+ * A class with `@Component` or `@Directive` is a component, whatever else it
+ * carries. Otherwise `@Pipe` makes it a pipe, and `@Service` or `@Injectable`
+ * a service, so that a pipe that is also injectable stays a pipe. Either is
+ * overruled by the `@Showcase` argument declaring a component-only field: such
+ * a class has been shown as a component so far, so it stays one
+ * (`legacy-component`) until 23.0.0, and the scan says why. That check comes
+ * first, before anything is said about the pipe itself.
+ *
+ * `showcaseArg` is read from the literal and from the evaluated value, since a
+ * constant or a spread can bring the field in and a field the evaluator cannot
+ * read is still in the literal.
+ */
+export declare function classifyShowcaseClass(classDecl: ts.ClassDeclaration, showcaseArg: ts.Expression | undefined, checker: ts.TypeChecker): ShowcaseClassKind;
+/**
+ * Whether Angular provides the service on its own (`auto`) or the user has to
+ * list it in a providers array (`manual`).
+ *
+ * `@Service()` is auto-provided unless it says `autoProvided: false`;
+ * `@Injectable` is when `providedIn` is `'root'`, `'platform'` or `'any'`.
+ * Anything else, such as no argument, no `providedIn`, a module class or a value
+ * the scan cannot read, is `manual`, without a warning: a service nobody
+ * provides is a normal thing to document.
+ */
+export declare function readProvision(decorator: ts.Decorator, checker: ts.TypeChecker): ServiceProvision;
+/**
+ * Read `name`, `pure` and `standalone` from the `@Pipe` metadata.
+ *
+ * Nothing that cannot be read is guessed: a `name` or `pure` the source does not
+ * give as a constant is left out, so that the caller can say so, while
+ * `standalone` only counts as `false` when the source says exactly that.
+ */
+export declare function readPipeOptions(decorator: ts.Decorator, checker: ts.TypeChecker): PipeOptions;
+export {};
+//# sourceMappingURL=angular-decorators.d.ts.map

package/dist/builder/scanner/api/angular-decorators.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"angular-decorators.d.ts","sourceRoot":"","sources":["../../../../src/builder/scanner/api/angular-decorators.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,YAAY,CAAC;AAC5B,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,kCAAkC,CAAC;AAezE,MAAM,MAAM,iBAAiB,GACvB;IAAE,IAAI,EAAE,WAAW,CAAA;CAAE;AACvB,wEAAwE;GACtE;IAAE,IAAI,EAAE,SAAS,CAAC;IAAC,SAAS,EAAE,EAAE,CAAC,SAAS,CAAA;CAAE;AAC9C,8GAA8G;GAC5G;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,EAAE,CAAC,SAAS,CAAA;CAAE;AAC3C;;;GAGG;GACD;IAAE,IAAI,EAAE,kBAAkB,CAAC;IAAC,MAAM,EAAE,MAAM,EAAE,CAAC;IAAC,MAAM,EAAE,YAAY,GAAG,MAAM,CAAC;IAAC,UAAU,CAAC,EAAE,KAAK,CAAA;CAAE,CAAC;AAExG,wEAAwE;AACxE,MAAM,WAAW,WAAW;IACxB,gHAAgH;IAChH,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,kGAAkG;IAClG,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,uGAAuG;IACvG,UAAU,EAAE,OAAO,CAAC;CACvB;AAED,KAAK,wBAAwB,GAAG,YAAY,GAAG,SAAS,GAAG,WAAW,GAAG,WAAW,GAAG,MAAM,CAAC;AAE9F;;;;;;;;;GASG;AACH,wBAAgB,wBAAwB,CAAC,SAAS,EAAE,EAAE,CAAC,gBAAgB,EAAE,IAAI,EAAE,wBAAwB,EAAE,OAAO,EAAE,EAAE,CAAC,WAAW,GAAG,EAAE,CAAC,SAAS,GAAG,SAAS,CAE1J;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,qBAAqB,CAAC,SAAS,EAAE,EAAE,CAAC,gBAAgB,EAAE,WAAW,EAAE,EAAE,CAAC,UAAU,GAAG,SAAS,EAAE,OAAO,EAAE,EAAE,CAAC,WAAW,GAAG,iBAAiB,CAuBxJ;AAED;;;;;;;;;GASG;AACH,wBAAgB,aAAa,CAAC,SAAS,EAAE,EAAE,CAAC,SAAS,EAAE,OAAO,EAAE,EAAE,CAAC,WAAW,GAAG,gBAAgB,CAsBhG;AAED;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,SAAS,EAAE,EAAE,CAAC,SAAS,EAAE,OAAO,EAAE,EAAE,CAAC,WAAW,GAAG,WAAW,CAqB7F"}