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

package/dist/builder/scanner/api/angular-decorators.js

@@ -0,0 +1,157 @@
+import ts from 'typescript';
+import { evaluateExpression, evaluateStatic, findDecorator, getDecoratorArgument, UNEVALUABLE } from '../ast-utils.js';
+const ANGULAR_CORE = '@angular/core';
+/**
+ * `@Showcase` fields that only a component can use. A class that carries
+ * one of them next to `@Injectable` or `@Pipe` is a component with that
+ * decorator, not a service or a pipe: showing it as one would drop the field.
+ */
+const COMPONENT_ONLY_FIELDS = ['variants', 'states', 'providers', 'bg', 'canvasLayout', 'host', 'renderPage', 'imports'];
+/** The values of `providedIn` that make Angular provide a service without anyone listing it. */
+const AUTO_PROVIDED_IN = ['root', 'platform', 'any'];
+/**
+ * {@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 function findAngularCoreDecorator(classDecl, name, checker) {
+    return ts.getDecorators(classDecl)?.find((decorator) => angularCoreName(decorator, checker) === name);
+}
+/**
+ * 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 function classifyShowcaseClass(classDecl, showcaseArg, checker) {
+    // Compared by name, as everywhere else in the scanner.
+    if (findDecorator(classDecl, 'Component') || findDecorator(classDecl, 'Directive'))
+        return { kind: 'component' };
+    const pipe = findAngularCoreDecorator(classDecl, 'Pipe', checker);
+    if (pipe) {
+        const fields = readComponentOnlyFields(showcaseArg, checker);
+        if (fields.length === 0)
+            return { kind: 'pipe', decorator: pipe };
+        return readPipeOptions(pipe, checker).standalone
+            ? { kind: 'legacy-component', fields, source: 'pipe' }
+            : { kind: 'legacy-component', fields, source: 'pipe', standalone: false };
+    }
+    const decorator = findAngularCoreDecorator(classDecl, 'Service', checker) ?? findAngularCoreDecorator(classDecl, 'Injectable', checker);
+    if (!decorator)
+        return { kind: 'component' };
+    const fields = readComponentOnlyFields(showcaseArg, checker);
+    return fields.length > 0 ? { kind: 'legacy-component', fields, source: 'injectable' } : { kind: 'service', decorator };
+}
+/**
+ * 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 function readProvision(decorator, checker) {
+    const isService = angularCoreName(decorator, checker) === 'Service';
+    const arg = getDecoratorArgument(decorator);
+    if (!arg)
+        return isService ? 'auto' : 'manual';
+    let unreadable = false;
+    const raw = evaluateStatic(arg, {
+        checker,
+        report: (issue) => {
+            // A `factory` is a runtime value and always dropped, which leaves the provision alone.
+            if (isService && issue.path[0] === 'autoProvided')
+                unreadable = true;
+        }
+    });
+    if (raw === UNEVALUABLE || typeof raw !== 'object' || raw === null)
+        return 'manual';
+    const options = raw;
+    if (isService)
+        return unreadable || options['autoProvided'] === false ? 'manual' : 'auto';
+    return AUTO_PROVIDED_IN.includes(options['providedIn']) ? 'auto' : 'manual';
+}
+/**
+ * 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 function readPipeOptions(decorator, checker) {
+    const arg = getDecoratorArgument(decorator);
+    let unreadable = false;
+    const raw = arg
+        ? evaluateStatic(arg, {
+            checker,
+            report: (issue) => {
+                // The whole argument or a spread that fails could have carried `pure` along, so it counts for it too.
+                if (issue.path.length === 0 || issue.path[0] === 'pure')
+                    unreadable = true;
+            }
+        })
+        : {};
+    const options = typeof raw === 'object' && raw !== null ? raw : {};
+    const result = { standalone: options['standalone'] !== false };
+    if (typeof options['name'] === 'string')
+        result.name = options['name'];
+    if (typeof options['pure'] === 'boolean')
+        result.pure = options['pure'];
+    else if (!unreadable && options['pure'] === undefined)
+        result.pure = true;
+    return result;
+}
+/**
+ * The name a decorator has in `@angular/core`, or `undefined` when it does not
+ * come from there: the imported name of an identifier, whatever it is called
+ * in the file, or the member of a namespace import.
+ */
+function angularCoreName(decorator, checker) {
+    const expr = ts.isCallExpression(decorator.expression) ? decorator.expression.expression : decorator.expression;
+    if (ts.isIdentifier(expr)) {
+        const specifier = checker.getSymbolAtLocation(expr)?.declarations?.find(ts.isImportSpecifier);
+        return specifier && importsAngularCore(specifier.parent.parent.parent) ? (specifier.propertyName ?? specifier.name).text : undefined;
+    }
+    if (ts.isPropertyAccessExpression(expr) && ts.isIdentifier(expr.expression)) {
+        const namespace = checker.getSymbolAtLocation(expr.expression)?.declarations?.find(ts.isNamespaceImport);
+        return namespace && importsAngularCore(namespace.parent.parent) ? expr.name.text : undefined;
+    }
+    return undefined;
+}
+function importsAngularCore(importDeclaration) {
+    return ts.isStringLiteral(importDeclaration.moduleSpecifier) && importDeclaration.moduleSpecifier.text === ANGULAR_CORE;
+}
+function readComponentOnlyFields(showcaseArg, checker) {
+    if (!showcaseArg)
+        return [];
+    const declared = new Set();
+    if (ts.isObjectLiteralExpression(showcaseArg)) {
+        for (const prop of showcaseArg.properties) {
+            if (prop.name && (ts.isIdentifier(prop.name) || ts.isStringLiteral(prop.name)))
+                declared.add(prop.name.text);
+        }
+    }
+    const evaluated = evaluateExpression(showcaseArg, checker);
+    if (typeof evaluated === 'object' && evaluated !== null) {
+        for (const key of Object.keys(evaluated))
+            declared.add(key);
+    }
+    return COMPONENT_ONLY_FIELDS.filter((field) => declared.has(field));
+}

package/dist/builder/scanner/api/component-api.extractor.d.ts

@@ -0,0 +1,13 @@
+import ts from 'typescript';
+import type { ComponentApi, InputMeta, OutputMeta } from '../../../plugin/plugin.types.js';
+import type { ClassHierarchy } from '../class-hierarchy.js';
+import type { ExportIndex } from './export-index.js';
+/**
+ * What the API page of a component or directive shows beyond `inputs` and
+ * `outputs`: the type of each input and the payload of each output, the
+ * change output of each `model()`, the documented methods, the description
+ * and tags of the class, and every documented type all of them reach, the
+ * inputs first, then the outputs, then the methods.
+ */
+export declare function extractComponentApi(classDecl: ts.ClassDeclaration, inputs: InputMeta[], outputs: OutputMeta[], hierarchy: ClassHierarchy, checker: ts.TypeChecker, exportIndex: ExportIndex): ComponentApi;
+//# sourceMappingURL=component-api.extractor.d.ts.map

package/dist/builder/scanner/api/component-api.extractor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"component-api.extractor.d.ts","sourceRoot":"","sources":["../../../../src/builder/scanner/api/component-api.extractor.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,YAAY,CAAC;AAC5B,OAAO,KAAK,EAAE,YAAY,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,iCAAiC,CAAC;AAG3F,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAG5D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAgBrD;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CAC/B,SAAS,EAAE,EAAE,CAAC,gBAAgB,EAC9B,MAAM,EAAE,SAAS,EAAE,EACnB,OAAO,EAAE,UAAU,EAAE,EACrB,SAAS,EAAE,cAAc,EACzB,OAAO,EAAE,EAAE,CAAC,WAAW,EACvB,WAAW,EAAE,WAAW,GACzB,YAAY,CAuCd"}

package/dist/builder/scanner/api/component-api.extractor.js

@@ -0,0 +1,104 @@
+import ts from 'typescript';
+import { findDecorator } from '../ast-utils.js';
+import { findInputDeclaration, findOutputDeclaration, getInstantiatedType, isModelInput, usesTypeParameters } from '../input.extractor.js';
+import { readDescription, readDocTags } from './doc-tags.js';
+import { extractDocumentedMethods } from './member.extractor.js';
+import { createTypeCollector } from './type-collector.js';
+/**
+ * What the API page of a component or directive shows beyond `inputs` and
+ * `outputs`: the type of each input and the payload of each output, the
+ * change output of each `model()`, the documented methods, the description
+ * and tags of the class, and every documented type all of them reach, the
+ * inputs first, then the outputs, then the methods.
+ */
+export function extractComponentApi(classDecl, inputs, outputs, hierarchy, checker, exportIndex) {
+    const collector = createTypeCollector(checker, exportIndex);
+    const inputTypes = {};
+    const outputTypes = {};
+    const modelChanges = [];
+    for (const { name, alias } of inputs) {
+        const declaration = findInputDeclaration(hierarchy, name);
+        if (!declaration)
+            continue;
+        // A type is reached by the name a template binds.
+        const pub = alias ?? name;
+        const { node, type } = readInputType(declaration, name, classDecl, checker);
+        const ref = collector.ref(node, type, `type of ${pub}`, { kind: 'property', name: pub });
+        inputTypes[name] = ref;
+        if (isModelInput(declaration.member))
+            modelChanges.push({ input: name, event: `${pub}Change`, type: ref });
+    }
+    for (const { name, alias } of outputs) {
+        const declaration = findOutputDeclaration(hierarchy, name);
+        if (!declaration)
+            continue;
+        const pub = alias ?? name;
+        const { node, type } = readOutputPayload(declaration, name, classDecl, checker);
+        outputTypes[name] = collector.ref(node, type, `payload of ${pub}`, { kind: 'property', name: pub });
+    }
+    const methods = extractDocumentedMethods(classDecl, checker, collector);
+    const api = { tags: readDocTags(classDecl), inputTypes, outputTypes, modelChanges, methods, types: collector.drain() };
+    const description = readDescription(classDecl);
+    if (description)
+        api.description = description;
+    return api;
+}
+/**
+ * The value an input takes, shown as written where it is written: the type
+ * argument of `input()` or `model()`, or the annotation of an `@Input()`.
+ * The type itself comes from the checker, so an input without either has one too.
+ */
+function readInputType(declaration, name, classDecl, checker) {
+    const { member } = declaration;
+    if (findDecorator(member, 'Input')) {
+        const instantiated = readInstantiatedType(declaration, member.type ?? member.initializer, name, classDecl, checker);
+        return instantiated ? { node: undefined, type: instantiated } : { node: member.type, type: checker.getTypeAtLocation(member) };
+    }
+    // Without the decorator, an input is a member initialized by a call to `input()` or `model()`.
+    const call = member.initializer;
+    const node = call.typeArguments?.[0];
+    const instantiated = readInstantiatedType(declaration, node ?? call.arguments[0], name, classDecl, checker);
+    const signal = instantiated ?? checker.getTypeAtLocation(member);
+    // A signal is a getter function, so its call signature returns the value type.
+    return { node: instantiated ? undefined : node, type: signal.getCallSignatures()[0]?.getReturnType() ?? signal };
+}
+/**
+ * What an output emits: the type argument of its type, `OutputEmitterRef<T>`
+ * or `EventEmitter<T>`, which is `void` for an `output()` without one. It is
+ * shown as written in `output<T>()`, `new EventEmitter<T>()` or the annotation.
+ */
+function readOutputPayload(declaration, name, classDecl, checker) {
+    const { member } = declaration;
+    const node = readCreatedPayload(member.initializer) ?? readAnnotatedPayload(member.type);
+    const instantiated = readInstantiatedType(declaration, node, name, classDecl, checker);
+    const emitter = instantiated ?? checker.getTypeAtLocation(member);
+    const isReference = emitter.flags & ts.TypeFlags.Object && emitter.objectFlags & ts.ObjectFlags.Reference;
+    // A type without type arguments says nothing about what it emits.
+    const type = (isReference ? checker.getTypeArguments(emitter)[0] : undefined) ?? checker.getUnknownType();
+    return { node: instantiated ? undefined : node, type };
+}
+/** `output<T>()` and `new EventEmitter<T>()`. */
+function readCreatedPayload(initializer) {
+    if (initializer && ts.isCallExpression(initializer) && ts.isIdentifier(initializer.expression) && initializer.expression.text === 'output') {
+        return initializer.typeArguments?.[0];
+    }
+    if (initializer && ts.isNewExpression(initializer) && ts.isIdentifier(initializer.expression) && initializer.expression.text === 'EventEmitter') {
+        return initializer.typeArguments?.[0];
+    }
+    return undefined;
+}
+/** `EventEmitter<T>`, `OutputEmitterRef<T>` or `Observable<T>` as annotated. */
+function readAnnotatedPayload(typeNode) {
+    return typeNode && ts.isTypeReferenceNode(typeNode) ? typeNode.typeArguments?.[0] : undefined;
+}
+/**
+ * The type of a member of a generic base class as the showcased class
+ * instantiates it, when what the member is declared with names the base's
+ * type parameters: `model<T>()` in `Field<T>` is a `number` on a class that
+ * extends `Field<number>`, and its annotation, which says `T`, is not shown.
+ * `undefined` for a member that does not use them, as `extractInputs`
+ * decides it: that one keeps its annotation, with the links in it.
+ */
+function readInstantiatedType({ owner }, declared, name, classDecl, checker) {
+    return owner !== classDecl && usesTypeParameters(declared, owner, checker) ? getInstantiatedType(name, classDecl, checker) : undefined;
+}

package/dist/builder/scanner/api/doc-tags.d.ts

@@ -0,0 +1,13 @@
+import ts from 'typescript';
+import type { ApiDocTags } from '../../../plugin/service.types.js';
+/** The comment text of a node without its tags, as written: line breaks and markdown stay. */
+export declare function readDescription(node: ts.Node): string | undefined;
+/** The tags of a node. Tags without a place in {@link ApiDocTags} are not read. */
+export declare function readDocTags(node: ts.Node): ApiDocTags;
+/** Whether a node has a doc block of its own, tags only or not. */
+export declare function isDocumented(node: ts.Node): boolean;
+/** Whether a node carries an `@internal` tag. */
+export declare function isInternal(node: ts.Node): boolean;
+/** The `@param` descriptions of a function-like node, by parameter name. */
+export declare function readParamDescriptions(node: ts.Node): Map<string, string>;
+//# sourceMappingURL=doc-tags.d.ts.map

package/dist/builder/scanner/api/doc-tags.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"doc-tags.d.ts","sourceRoot":"","sources":["../../../../src/builder/scanner/api/doc-tags.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,YAAY,CAAC;AAC5B,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kCAAkC,CAAC;AAgCnE,8FAA8F;AAC9F,wBAAgB,eAAe,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,GAAG,MAAM,GAAG,SAAS,CAEjE;AAED,mFAAmF;AACnF,wBAAgB,WAAW,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,GAAG,UAAU,CAgCrD;AAED,mEAAmE;AACnE,wBAAgB,YAAY,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,GAAG,OAAO,CAEnD;AAED,iDAAiD;AACjD,wBAAgB,UAAU,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,GAAG,OAAO,CAEjD;AAED,4EAA4E;AAC5E,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,GAAG,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAaxE"}

package/dist/builder/scanner/api/doc-tags.js

@@ -0,0 +1,101 @@
+import ts from 'typescript';
+/**
+ * The block that documents a node: the last `/** *\/` above it, as long as it
+ * sits right on top of the node and says something. Line comments in between,
+ * such as `// eslint-disable-next-line`, keep it attached. TypeScript also
+ * attaches a block that floats a few lines above, such as a section banner,
+ * and one that is only a ruler (`/** ===== *\/`); neither describes the node.
+ */
+function readDocBlock(node) {
+    const blocks = node.jsDoc;
+    const block = blocks?.[blocks.length - 1];
+    if (!block)
+        return undefined;
+    const sourceFile = node.getSourceFile();
+    // The first line is the rest of the block's last line, the last one the indentation of the node.
+    const linesBetween = sourceFile.text.slice(block.end, node.getStart(sourceFile)).split('\n').slice(1, -1);
+    if (linesBetween.some((line) => !/^\s*\/\//.test(line)))
+        return undefined;
+    const stripped = block.getText(sourceFile).replace(/[/*\s]/g, '');
+    if (stripped.length === 0 || /^[*=\-_#~]+$/.test(stripped))
+        return undefined;
+    return block;
+}
+function commentText(comment) {
+    return ts.getTextOfJSDocComment(comment)?.trim() || undefined;
+}
+/** The comment text of a node without its tags, as written: line breaks and markdown stay. */
+export function readDescription(node) {
+    return commentText(readDocBlock(node)?.comment);
+}
+/** The tags of a node. Tags without a place in {@link ApiDocTags} are not read. */
+export function readDocTags(node) {
+    const result = {};
+    for (const tag of readDocBlock(node)?.tags ?? []) {
+        const comment = commentText(tag.comment);
+        switch (tag.tagName.text) {
+            case 'deprecated':
+                result.deprecated = comment ?? true;
+                break;
+            case 'since':
+                if (comment)
+                    result.since = comment;
+                break;
+            case 'version':
+                if (comment)
+                    result.version = comment;
+                break;
+            case 'default':
+                if (comment)
+                    result.default = comment;
+                break;
+            case 'see': {
+                const reference = readSeeReference(tag);
+                if (reference)
+                    result.see = [...(result.see ?? []), reference];
+                break;
+            }
+            case 'example':
+                if (comment)
+                    result.example = [...(result.example ?? []), comment];
+                break;
+        }
+    }
+    return result;
+}
+/** Whether a node has a doc block of its own, tags only or not. */
+export function isDocumented(node) {
+    return readDocBlock(node) !== undefined;
+}
+/** Whether a node carries an `@internal` tag. */
+export function isInternal(node) {
+    return readDocBlock(node)?.tags?.some((tag) => tag.tagName.text === 'internal') ?? false;
+}
+/** The `@param` descriptions of a function-like node, by parameter name. */
+export function readParamDescriptions(node) {
+    const result = new Map();
+    for (const tag of readDocBlock(node)?.tags ?? []) {
+        if (!ts.isJSDocParameterTag(tag) || !ts.isIdentifier(tag.name))
+            continue;
+        // `@param name - text` is the TSDoc spelling; the dash is not part of the text.
+        const description = commentText(tag.comment)?.replace(/^-\s+/, '');
+        if (description)
+            result.set(tag.name.text, description);
+    }
+    return result;
+}
+/**
+ * What a `@see` points at: the target of a `{@link}`, a name, or a URL. The
+ * parser reads a URL as a name followed by `://…` and leaves a stray `*` of the
+ * next line behind, so the tag is read from the source instead of from its parts.
+ */
+function readSeeReference(tag) {
+    const body = tag
+        .getSourceFile()
+        .text.slice(tag.tagName.end, tag.end)
+        .split('\n')
+        .map((line) => line.replace(/^\s*\*?\s*/, ''))
+        .join(' ')
+        .trim();
+    return /^\{@link(?:code|plain)?\s+([^\s}|]+)/.exec(body)?.[1] ?? (body.split(/\s+/)[0] || undefined);
+}

package/dist/builder/scanner/api/export-index.d.ts

@@ -0,0 +1,18 @@
+import ts from 'typescript';
+/** Where a symbol can be imported from: the resolved symbol of an export, and the `importPath` of the entry point that exports it. */
+export type ExportIndex = ReadonlyMap<ts.Symbol, string>;
+/**
+ * Index everything the library's entry points export by its resolved symbol,
+ * so that a reference found anywhere in the source can be traced to the entry
+ * point a consumer imports it from. A re-export (`export { x } from`) is an
+ * alias and is followed to the declaration, which is what a reference resolves
+ * to as well.
+ *
+ * A symbol exported more than once keeps the first entry: callers put the
+ * secondary entry points before the primary one, as the component dedupe does.
+ */
+export declare function buildExportIndex(entries: ReadonlyArray<{
+    exports: ts.Symbol[];
+    importPath: string;
+}>, checker: ts.TypeChecker): ExportIndex;
+//# sourceMappingURL=export-index.d.ts.map

package/dist/builder/scanner/api/export-index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"export-index.d.ts","sourceRoot":"","sources":["../../../../src/builder/scanner/api/export-index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,YAAY,CAAC;AAE5B,sIAAsI;AACtI,MAAM,MAAM,WAAW,GAAG,WAAW,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;AAEzD;;;;;;;;;GASG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,aAAa,CAAC;IAAE,OAAO,EAAE,EAAE,CAAC,MAAM,EAAE,CAAC;IAAC,UAAU,EAAE,MAAM,CAAA;CAAE,CAAC,EAAE,OAAO,EAAE,EAAE,CAAC,WAAW,GAAG,WAAW,CAY3I"}

package/dist/builder/scanner/api/export-index.js

@@ -0,0 +1,22 @@
+import ts from 'typescript';
+/**
+ * Index everything the library's entry points export by its resolved symbol,
+ * so that a reference found anywhere in the source can be traced to the entry
+ * point a consumer imports it from. A re-export (`export { x } from`) is an
+ * alias and is followed to the declaration, which is what a reference resolves
+ * to as well.
+ *
+ * A symbol exported more than once keeps the first entry: callers put the
+ * secondary entry points before the primary one, as the component dedupe does.
+ */
+export function buildExportIndex(entries, checker) {
+    const index = new Map();
+    for (const { exports, importPath } of entries) {
+        for (const sym of exports) {
+            const resolved = sym.flags & ts.SymbolFlags.Alias ? checker.getAliasedSymbol(sym) : sym;
+            if (!index.has(resolved))
+                index.set(resolved, importPath);
+        }
+    }
+    return index;
+}

package/dist/builder/scanner/api/member.extractor.d.ts

@@ -0,0 +1,90 @@
+import ts from 'typescript';
+import type { ApiMethod, ApiProperty, ApiTypeRef } from '../../../plugin/service.types.js';
+/** What a type is the type of: a property, a parameter of a method, or what a method returns. */
+export type TypeSite = {
+    kind: 'property';
+    name: string;
+} | {
+    kind: 'parameter';
+    name: string;
+    method: string;
+} | {
+    kind: 'return';
+    method: string;
+};
+/**
+ * Turns the type of a member, parameter or return value into an {@link ApiTypeRef}.
+ * `reachedFrom` says where it was met, e.g. `parameter of show()`, and `site`
+ * the same in parts, for a resolver that documents the types it finds on the
+ * way and follows their members.
+ */
+export interface TypeRefResolver {
+    ref(typeNode: ts.TypeNode | undefined, type: ts.Type, reachedFrom: string, site?: TypeSite): ApiTypeRef;
+}
+type MethodLike = ts.MethodDeclaration | ts.MethodSignature;
+/** A type as written, or as the checker prints it when there is nothing written. Whitespace is collapsed, so a multi-line literal type stays on one line. */
+export declare function readTypeText(checker: ts.TypeChecker, typeNode: ts.TypeNode | undefined, type: ts.Type): string;
+/** Gives the text of a type and nothing else: no links, no documented types. */
+export declare function textOnlyResolver(checker: ts.TypeChecker): TypeRefResolver;
+/**
+ * The public instance members of a class and of its base classes, nearest
+ * class first and in source order. A class that declares a name hides it in
+ * the classes above, whatever it declares: an `@internal` override removes
+ * the member, a redeclaration replaces the inherited one. A static member
+ * hides nothing, as it is not an instance member.
+ *
+ * Left out: `private`, `protected` and `#` members, names with a `_` prefix,
+ * lifecycle hooks, the constructor, statics and what is tagged `@internal`.
+ * The constructor's parameter properties (`constructor(readonly id: string)`)
+ * are properties, in the constructor's place, described by its `@param`.
+ * Methods are listed with or without JSDoc. A redeclaration without JSDoc of
+ * its own keeps its signature, but takes description, tags and `@param` texts
+ * from the nearest base class member of that name that has them.
+ */
+export declare function extractMembers(classDecl: ts.ClassDeclaration, checker: ts.TypeChecker, types: TypeRefResolver): {
+    properties: ApiProperty[];
+    methods: ApiMethod[];
+};
+/**
+ * The methods {@link extractMembers} lists, but only those with docs of their
+ * own or taken from a base class member of that name. A component's public
+ * methods are often only there for its own template; the documented ones are
+ * those meant to be called from outside.
+ */
+export declare function extractDocumentedMethods(classDecl: ts.ClassDeclaration, checker: ts.TypeChecker, types: TypeRefResolver): ApiMethod[];
+/**
+ * The members of an interface or an object literal type, the inherited ones
+ * included, own members first. What is tagged `@internal` is left out; there
+ * is nothing private to leave out.
+ */
+export declare function extractObjectTypeMembers(type: ts.Type, checker: ts.TypeChecker, types: TypeRefResolver): {
+    properties: ApiProperty[];
+    methods: ApiMethod[];
+};
+/**
+ * The signatures a caller can use of a method that `declarations` declare in
+ * one class, in source order: its overload signatures, or the one declaration
+ * when there are none. The implementation of overloads is not one a caller
+ * can use. In a .d.ts every declaration is a signature.
+ *
+ * A signature without a doc block of its own takes the one of the
+ * implementation, then of the first documented signature, then `inherited`,
+ * the documented declaration of the method in the nearest base class that has
+ * one. The implementation and a base class document the method as a whole, so
+ * all of their block is taken. Another signature's block is about that
+ * signature: its description and `@param` texts are taken, its tags are not,
+ * since an overload marked `@deprecated` does not deprecate the one that
+ * replaces it.
+ */
+export declare function extractOverloads(name: string, declarations: MethodLike[], inherited: ts.Node | undefined, checker: ts.TypeChecker, types: TypeRefResolver): ApiMethod[];
+/**
+ * The signature of a method, or of a function such as a setup function, with
+ * the doc block read from `docs`: the declaration itself, the statement of a
+ * `const` arrow function, or a declaration it inherits the docs of.
+ */
+export declare function extractMethod(name: string, declaration: ts.SignatureDeclaration, docs: ts.Node, checker: ts.TypeChecker, types: TypeRefResolver): ApiMethod;
+/** The first parameter that is not `this`. */
+export declare function firstParameter(declaration: ts.SignatureDeclaration): ts.ParameterDeclaration | undefined;
+export declare function collapseWhitespace(text: string): string;
+export {};
+//# sourceMappingURL=member.extractor.d.ts.map

package/dist/builder/scanner/api/member.extractor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"member.extractor.d.ts","sourceRoot":"","sources":["../../../../src/builder/scanner/api/member.extractor.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,YAAY,CAAC;AAC5B,OAAO,KAAK,EAAE,SAAS,EAAY,WAAW,EAAE,UAAU,EAAE,MAAM,kCAAkC,CAAC;AAIrG,iGAAiG;AACjG,MAAM,MAAM,QAAQ,GAAG;IAAE,IAAI,EAAE,UAAU,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAAG;IAAE,IAAI,EAAE,WAAW,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,GAAG;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC;AAErJ;;;;;GAKG;AACH,MAAM,WAAW,eAAe;IAC5B,GAAG,CAAC,QAAQ,EAAE,EAAE,CAAC,QAAQ,GAAG,SAAS,EAAE,IAAI,EAAE,EAAE,CAAC,IAAI,EAAE,WAAW,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,QAAQ,GAAG,UAAU,CAAC;CAC3G;AAiBD,KAAK,UAAU,GAAG,EAAE,CAAC,iBAAiB,GAAG,EAAE,CAAC,eAAe,CAAC;AAE5D,6JAA6J;AAC7J,wBAAgB,YAAY,CAAC,OAAO,EAAE,EAAE,CAAC,WAAW,EAAE,QAAQ,EAAE,EAAE,CAAC,QAAQ,GAAG,SAAS,EAAE,IAAI,EAAE,EAAE,CAAC,IAAI,GAAG,MAAM,CAE9G;AAED,gFAAgF;AAChF,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,EAAE,CAAC,WAAW,GAAG,eAAe,CAIzE;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,cAAc,CAAC,SAAS,EAAE,EAAE,CAAC,gBAAgB,EAAE,OAAO,EAAE,EAAE,CAAC,WAAW,EAAE,KAAK,EAAE,eAAe,GAAG;IAAE,UAAU,EAAE,WAAW,EAAE,CAAC;IAAC,OAAO,EAAE,SAAS,EAAE,CAAA;CAAE,CAUnK;AAED;;;;;GAKG;AACH,wBAAgB,wBAAwB,CAAC,SAAS,EAAE,EAAE,CAAC,gBAAgB,EAAE,OAAO,EAAE,EAAE,CAAC,WAAW,EAAE,KAAK,EAAE,eAAe,GAAG,SAAS,EAAE,CAIrI;AAyCD;;;;GAIG;AACH,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,EAAE,OAAO,EAAE,EAAE,CAAC,WAAW,EAAE,KAAK,EAAE,eAAe,GAAG;IAAE,UAAU,EAAE,WAAW,EAAE,CAAC;IAAC,OAAO,EAAE,SAAS,EAAE,CAAA;CAAE,CA0B5J;AAiFD;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,YAAY,EAAE,UAAU,EAAE,EAAE,SAAS,EAAE,EAAE,CAAC,IAAI,GAAG,SAAS,EAAE,OAAO,EAAE,EAAE,CAAC,WAAW,EAAE,KAAK,EAAE,eAAe,GAAG,SAAS,EAAE,CAcvK;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,WAAW,EAAE,EAAE,CAAC,oBAAoB,EAAE,IAAI,EAAE,EAAE,CAAC,IAAI,EAAE,OAAO,EAAE,EAAE,CAAC,WAAW,EAAE,KAAK,EAAE,eAAe,GAAG,SAAS,CAe3J;AAoBD,8CAA8C;AAC9C,wBAAgB,cAAc,CAAC,WAAW,EAAE,EAAE,CAAC,oBAAoB,GAAG,EAAE,CAAC,oBAAoB,GAAG,SAAS,CAExG;AA2BD,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAEvD"}