@arcgis/lumina-compiler 4.32.0-next.2 → 4.32.0-next.20

package/dist/context/index.d.ts

@@ -1,41 +1,63 @@
 import type { ConfigEnv, Plugin, ResolvedConfig, ViteDevServer } from "vite";
 import ts from "typescript";
-import type { LuminaOptions, AssetSpec, AssetTransformer, DeclarationTextTransformer, ProvideAssetsOptions } from "../publicTypes";
-import type { ExtendedComponentManifest } from "../manifests/complexTypes/types";
+import type { ApiCssCustomProperty, ApiCustomElementDeclaration, ApiJson } from "@arcgis/api-extractor";
+import type { LuminaOptions, AssetSpec, AssetTransformer, DeclarationTextTransformer, ProvideAssetsOptions, LintingOptions } from "../publicTypes";
 import type { ComponentPathMapping } from "../entrypoints/pathMapping";
-import type { ManifestType } from "../manifests/types";
-import type { ComponentManifest } from "../manifests/utils";
+import type { DocsType } from "../docs/types";
 import type { ContextDirectories } from "./types";
+import { makeLoaders, type computeServeOnlyDependencies } from "../dependencies/loaders";
+import type { CustomElementInterdependencies } from "../entrypoints/config";
+import type { getCompilerOptionsForPrinter } from "../transformers";
+import type { getPrinter } from "../transformers/internalTypeScriptApis";
+import type { getLocalDefinedComponentsFromApiJson } from "../entrypoints/resolveTagName";
+import type { Deferred } from "@arcgis/components-utils";
 export declare class CompilerContext {
     /**
-     * The path to a resolved TypeScript config file
+     * The path to the resolved TypeScript configuration
      */
-    readonly typeScriptConfigPath: string;
+    typeScriptConfigPath: string;
     /**
-     * The resolved TypeScript config file
+     * The parsed TypeScript configuration
      */
-    readonly typeScriptConfig: ts.ParsedCommandLine;
+    typeScriptConfig: ts.CompilerOptions;
     /**
      * An instance of TypeScript program. Contains all .tsx source files present
-     * in the project
+     * in the project.
      *
-     * TypeScript program is created only in build mode, not in serve
+     * TypeScript program is created only in build mode and in storybook. It
+     * is not created in serve.
      */
     typeScriptProgram?: ts.Program;
     /**
-     * An instance of TypeScript type checker
+     * An instance of TypeScript type checker.
      *
-     * TypeScript type checker is created only in build mode, not in serve
+     * TypeScript type checker is created only in build mode and in storybook. It
+     * is not created in serve.
      */
     typeScriptTypeChecker?: ts.TypeChecker;
+    /**
+     * A TypeScript watcher program. Created only when running under Storybook in
+     * serve mode.
+     */
+    typeScriptWatchProgram?: ts.WatchOfConfigFile<ts.BuilderProgram>;
     /**
      * An instance of TypeScript compiler host
      */
     typeScriptHost: ts.CompilerHost;
     /**
      * TypeScript source file instances created in serve mode
+     *
+     * @private
      */
-    private _typeScriptSourceFiles;
+    private readonly _typeScriptSourceFiles;
+    /**
+     * Used in Storybook watch mode. Resolves once TypeScript program is
+     * re-created in response to a file change. This is used to halt the Vite from
+     * doing hot-module-reload until the TypeScript program is re-created.
+     *
+     * @private
+     */
+    _typeScriptReload?: Deferred<void>;
     /**
      * Whether minification is enabled for transformed JSX (lit-html templates)
      * and generated component code.
@@ -55,33 +77,57 @@ export declare class CompilerContext {
      * A vite plugin that sets the initial context information based on Vite
      * environment
      *
-     * @internal
+     * @private
      */
-    readonly plugin: Plugin;
+    readonly _plugin: Plugin;
     /**
      * List of directories of common interest to the compiler
      */
     dir: ContextDirectories;
     /**
-     * The custom-element-manifest, also known as custom-element.json
+     * The api.json stores information about the structure of all components in
+     * the package (their properties, methods, events, JSDoc and etc).
      *
-     * Stores information about the structure of all components in the package
-     * (their properties, methods, events, JSDoc and etc).
-     *
-     * You can augment the manifest generation using the `manifest` option on
+     * You can augment the api.json generation using the `apiJson` option in
      * `useLumina()`
+     */
+    apiJson: ApiJson;
+    /**
+     * A flattened api.json listing all components in this package.
+     */
+    apiJsonComponents: ApiCustomElementDeclaration[];
+    /**
+     * Like this.apiJson, but also contains members decorated with the `@private`
+     * JSDoc tag.
+     */
+    privateApiJson: ApiJson;
+    /**
+     * @private
+     */
+    _componentPathMapping: ComponentPathMapping;
+    /**
+     * Cached result of getLocalDefinedComponentsFromApiJson() call
      *
-     * @see https://custom-elements-manifest.open-wc.org/analyzer/getting-started/
+     * @private
      */
-    manifest: ExtendedComponentManifest;
+    _localDefinedComponents?: ReturnType<typeof getLocalDefinedComponentsFromApiJson>;
     /**
-     * A flattened custom-element-manifest listing all components in this package.
+     * Mapping of css files and which components they are imported in.
+     *
+     * @private
      */
-    manifestComponents: ComponentManifest[];
+    readonly _cssImports: Map<string, Set<string> | undefined>;
     /**
-     * @internal
+     * Mapping of CSS file names to docs extracted from them.
+     *
+     * CSS files are read during the file transform stage, which is after the
+     * api.json is extracted. This unfortunately means that we have to mutate
+     * the api.json after the fact to add the CSS docs. Furthermore, when api.json
+     * is re-generated, we need to re-add the CSS docs previously extracted.
+     *
+     * @private
      */
-    componentPathMapping: ComponentPathMapping;
+    _cssDocs?: Map<string, ApiCssCustomProperty[] | undefined>;
     /**
      * The environment that Vite is running in
      *
@@ -149,6 +195,14 @@ export declare class CompilerContext {
      * should not try to read this property before the `apply()` hook is called.
      */
     viteCommand: ConfigEnv["command"];
+    /**
+     * Whether to extract full API information, with type-checking. This is the
+     * case during build or when running under Storybook. Otherwise, the dev
+     * server keeps API extraction to bare minimum to reduce needless overhead.
+     * Only the information necessary for the dev server to lazy load is
+     * extracted.
+     */
+    isFullApiExtraction: boolean;
     readonly banner: string;
     /**
      * `@arcgis/lumina-compiler` plugins may register additional `.d.ts`
@@ -156,19 +210,19 @@ export declare class CompilerContext {
      * option, use the `types.declarationTextTransformers` option on the
      * `useLumina` Vite plugin.
      *
-     * @internal
+     * @private
      */
-    readonly declarationTextTransformers: DeclarationTextTransformer[];
+    readonly _declarationTextTransformers: DeclarationTextTransformer[];
     /**
      * Options passed to `useLumina()`
      */
-    options: LuminaOptions;
+    readonly options: LuminaOptions;
     /**
      * Resolved file names for documentation files
      *
-     * @internal
+     * @private
      */
-    documentationFileNames: Record<ManifestType, string>;
+    readonly _documentationFileNames: Record<DocsType, string | undefined>;
     /**
      * Resolved Vite configuration
      */
@@ -180,13 +234,13 @@ export declare class CompilerContext {
     /**
      * Whether configServer() hook has already been called
      *
-     * @internal
+     * @private
      */
-    serverConfigured: boolean;
+    _serverConfigured: boolean;
     /**
      * Assets pending to be served
      *
-     * @internal
+     * @private
      */
     assetsToProvide: ProvideAssetsOptions[] | undefined;
     /**
@@ -198,19 +252,70 @@ export declare class CompilerContext {
      * Style for hiding custom elements before they are loaded. This is appended
      * to the global stylesheet.
      *
-     * @internal
+     * @private
      */
-    globalHydratedCssString: string;
+    _globalHydratedCssString: string;
     /**
      * Contents of the bundled global CSS file
      *
-     * @internal
+     * @private
      */
-    globalCssString?: string;
+    _globalCssString?: string;
     /**
      * A list of file names that declare one or more components
      */
     componentFiles: string[];
+    /**
+     * Cached result of makeLoaders() call
+     *
+     * @private
+     */
+    _loadersCache?: ReturnType<typeof makeLoaders>;
+    /**
+     * Cached result of computeServeOnlyDependencies() call
+     *
+     * @private
+     */
+    _serveOnlyDependencies?: ReturnType<typeof computeServeOnlyDependencies>;
+    /**
+     * Data structure that stores references between class components and between
+     * functional components.
+     * This is used in build mode only.
+     *
+     * @private
+     */
+    readonly _customElementDependencies: CustomElementInterdependencies;
+    /**
+     * Result of getCompilerOptionsForPrinter() call.
+     *
+     * @internal
+     */
+    _compilerOptionsForPrinter: ReturnType<typeof getCompilerOptionsForPrinter>;
+    /**
+     * Cached result of getPrinter() call. Cached to not needlessly create and
+     * throw away a printer instance for each transformed file.
+     *
+     * @internal
+     */
+    _typeScriptPrinter: ReturnType<typeof getPrinter>;
+    /**
+     * Cached RegExp for replacing occurrences of `ArcgisCounter["el"]` with
+     * `HtmlElementArcgisCounter`.
+     *
+     * @internal
+     */
+    _htmlElementReferencesReplacer?: {
+        regex: RegExp;
+        replacements: Record<string, string>;
+    };
+    /**
+     * Mapping between component tag name and public properties in that component
+     * whose type depends on another property.
+     *
+     * @internal
+     */
+    _typeDependencies: Map<string, Set<string>>;
+    private _silencedRules;
     constructor(options: LuminaOptions);
     private _inferBuildSetup;
     /**
@@ -247,4 +352,5 @@ export declare class CompilerContext {
      * ```
      */
     provideAssets(assets: AssetSpec[], transformers?: AssetTransformer[], apply?: CompilerContext["viteCommand"]): void;
+    logLintError(rule: keyof LintingOptions["silence"], absoluteFilePath: string, error: string): void;
 }

package/dist/context/typeScript.d.ts

@@ -0,0 +1,19 @@
+import ts from "typescript";
+import type { CompilerContext } from ".";
+/**
+ * In build mode, vite-plugin-dts already parses tsconfig. However, it
+ * overwrites the resolved tsconfig.target with ESNext, which is not what we
+ * want (we need the real tsconfig.target for the CDN build). Thus, we have
+ * to resolve the tsconfig ahead of time manually.
+ *
+ * In dev server, practically the only use for a TypeScript config is the
+ * getPrinter() call. It's also used in ts.createSourceFile(), but looks
+ * like that can be safely called with the latest target.
+ */
+export declare function loadTypeScriptConfig(context: CompilerContext): void;
+/**
+ * Convert TypeScript ECMA target version number into an ESBuild target version
+ * string
+ */
+export declare function resolveTargetVersion(typeScriptConfig: Pick<ts.CompilerOptions, "target">): string;
+export declare function loadTypeScript(context: CompilerContext): void;

package/dist/context/utils.d.ts

@@ -1,23 +1,4 @@
-import ts from "typescript";
-/**
- * While vite-plugin-dts already parses tsconfig, it overwrites the resolved
- * tsconfig.target with ESNext, which is not what we want (we need the real
- * tsconfig.target for the CDN build). Thus, have to resolve the tsconfig
- * ahead of time manually. This is partially redundant and slows down the
- * build a bit
- */
-export declare function loadTypeScriptConfig(tsConfigPath?: string): {
-    readonly path: string;
-    readonly config: ts.ParsedCommandLine;
-};
-export declare function inferPreamble(packageJson?: import("../utils/packageJson").MiniPackageJson): string;
+export declare function inferPreamble(packageJson?: import("@arcgis/components-build-utils").MiniPackageJson): string;
 export declare const preambleToComment: (preamble: string) => string;
 export declare const throwOnReadBeforeSet: (createdDuring: string) => PropertyDecorator;
-/**
- * Convert TypeScript ECMA target version number into an ESBuild target version
- * string
- */
-export declare function resolveTargetVersion(typeScriptConfig: {
-    options: Pick<ts.CompilerOptions, "target">;
-}): string;
 export declare function normalizeDocumentationFileName(fileName: string): string;

package/dist/dependencies/discover.d.ts

@@ -1,6 +1,6 @@
 import type { Package } from "custom-elements-manifest/schema";
-import type { ModulePath } from "../manifests/complexTypes/transformUtils";
-import type { WebTypes } from "../manifests/webTypes/types";
+import type { ModulePath } from "../extractor/helpers/resolveType";
+import type { WebTypes } from "../docs/webTypes/types";
 export type ResolvedDependencyComponents = {
     readonly packageName: string;
     readonly type: "@arcgis/lumina" | "stencil" | "unknown";
@@ -34,7 +34,7 @@ export type ResolvedDependencyComponent = ModulePath & {
  *
  * Process:
  * - For each peer and dev dependency:
- *   - If it has manifest.json, read from there (Lumina libraries
+ *   - If it has custom-elements-manifest, read from there (Lumina libraries
  *     and popular community libraries)
  *   - Else if has web-types.json, read from there (Vaadin and others)
  *   - Else, if it has dist/esm/loader.js (Stencil), read from there
@@ -52,9 +52,9 @@ export declare function findPackageComponents(packageName: string, cwd?: string)
 /**
  * Given the custom element manifest, find custom elements defined in it
  */
-export declare const manifestToDependencyComponents: (manifest: Package, dependency: Omit<ModulePath, "moduleName"> & {
+export declare function manifestToDependencyComponents(manifest: Package, dependency: Omit<ModulePath, "moduleName"> & {
     readonly getImportPath: (tagName: string) => string;
-}) => ResolvedDependencyComponents["components"];
+}): ResolvedDependencyComponents["components"];
 export declare const webTypesToDependencyComponents: (webTypes: Partial<WebTypes>, dependency: Omit<ModulePath, "moduleName"> & {
     readonly packageRoot: string | undefined;
     readonly getImportPath: (tagName: string) => string;

package/dist/dependencies/updateLumina.d.ts

@@ -1,7 +1,7 @@
 import type { ResolvedDependencyComponents } from "./discover";
 import type { BrowserConfigOptions } from "vitest/node";
-export declare function updateLuminaTs(dependencies: readonly ResolvedDependencyComponents[], srcDir: string, hasCore: boolean, browserProvider?: BrowserConfigOptions["provider"], packageJson?: import("../utils/packageJson").MiniPackageJson): Promise<void>;
-declare function produceLuminaTs(dependencies: readonly ResolvedDependencyComponents[], hasCore: boolean, browserProvider?: BrowserConfigOptions["provider"], packageJson?: import("../utils/packageJson").MiniPackageJson): string;
+export declare function updateLuminaTs(dependencies: readonly ResolvedDependencyComponents[], srcDir: string, hasCore: boolean, browserProvider?: BrowserConfigOptions["provider"], packageJson?: import("@arcgis/components-build-utils").MiniPackageJson): Promise<void>;
+declare function produceLuminaTs(dependencies: readonly ResolvedDependencyComponents[], hasCore: boolean, browserProvider?: BrowserConfigOptions["provider"], packageJson?: import("@arcgis/components-build-utils").MiniPackageJson): string;
 export declare const exportsForTests: {
     produceLuminaTs: typeof produceLuminaTs;
 };

package/dist/docs/config.d.ts

@@ -0,0 +1,2 @@
+import type { DocsType } from "./types";
+export declare const defaultDocsFileNames: Record<DocsType, string>;

package/dist/{manifests/stencilManifest.d.ts → docs/stencilDocsJson.d.ts}

@@ -1,11 +1,12 @@
 import type { JsonDocs } from "@stencil/core/internal";
 import type { CompilerContext } from "../context";
 /**
- * Create a stencil-compatible docs.json manifest.
+ * Create a stencil-compatible docs.json file describing the library components.
+ *
  * While custom-elements-manifest is the most popular community standard and is
  * natively supported by Storybook and other tools, Esri has several internal
- * tools that expect the Stencil-style docs.json manifest.
- * Since they are similar in content, generating a Stencil-compatible manifest
+ * tools that expect the Stencil-style docs.json.
+ * Since they are similar in content, generating a Stencil-compatible docs.json
  * will smooth the migration path.
  *
  * @remarks
@@ -14,4 +15,4 @@ import type { CompilerContext } from "../context";
  * generates:
  * https://github.com/ionic-team/stencil/blob/9f5f9cdd023b8c8dfb5417a1a970605ba724ae28/src/compiler/docs/generate-doc-data.ts#L98
  */
-export declare const generateStencilManifest: (context: CompilerContext) => JsonDocs;
+export declare const generateStencilDocsJson: (context: CompilerContext) => JsonDocs;

package/dist/docs/types.d.ts

@@ -0,0 +1 @@
+export type DocsType = "apiJson" | "stencilLikeDocsJson" | "vsCodeCss" | "vsCodeHtml" | "webTypes";

package/dist/{manifests → docs}/vsCodeCustomData/index.d.ts

@@ -1,5 +1,5 @@
-import type { VsCodeHtmlDocs, VsCodeCssDocs, VsCodeDocOptions } from "./types.js";
-import type { ComponentManifest } from "../utils.js";
+import type { VsCodeHtmlDocs, VsCodeCssDocs } from "./types.js";
+import type { ApiCustomElementDeclaration } from "@arcgis/api-extractor";
 /**
  * Originally based on
  * https://github.com/break-stuff/cem-tools/tree/main/packages/vs-code-integration
@@ -12,5 +12,5 @@ import type { ComponentManifest } from "../utils.js";
  *
  * But also there are several other quality issues with the original plugin.
  */
-export declare const generateVsCodeHtmlCustomData: (components: ComponentManifest[], options: VsCodeDocOptions) => VsCodeHtmlDocs;
-export declare const generateVsCodeCssCustomData: (components: ComponentManifest[]) => VsCodeCssDocs;
+export declare const generateVsCodeHtmlCustomData: (components: ApiCustomElementDeclaration[]) => VsCodeHtmlDocs;
+export declare const generateVsCodeCssCustomData: (components: ApiCustomElementDeclaration[]) => VsCodeCssDocs;

package/dist/{manifests → docs}/vsCodeCustomData/types.d.ts

@@ -1,10 +1,8 @@
 export type VsCodeDocOptions = {
     /** @default "docs/vscode.html-custom-data.json" */
-    htmlFileName?: string | null;
+    htmlFileName?: string;
     /** @default "docs/vscode.css-custom-data.json" */
-    cssFileName?: string | null;
-    /** Used to create an array of links within the component info bubble */
-    referencesTemplate?: (name: string, tag: string) => VsCodeReference[];
+    cssFileName?: string;
 };
 export type VsCodeHtmlDocs = {
     $schema: string;

package/dist/docs/vsCodeCustomData/utils.d.ts

@@ -0,0 +1,3 @@
+import type { VsCodeTag } from "./types";
+import { type ApiCustomElementDeclaration } from "@arcgis/api-extractor";
+export declare const getTagList: (components: ApiCustomElementDeclaration[]) => VsCodeTag[];

package/dist/docs/webTypes/description.d.ts

@@ -0,0 +1,7 @@
+import { type ApiClassMember, type ApiCssCustomProperty, type ApiCssPart, type ApiCustomElementDeclaration, type ApiEvent, type ApiSlot } from "@arcgis/api-extractor";
+export declare function getComponentDetailsTemplate(component: ApiCustomElementDeclaration): string;
+export declare const getSlotsTemplate: (slots?: ApiSlot[]) => string;
+export declare const getEventsTemplate: (events?: ApiEvent[]) => string;
+export declare const getCssPropsTemplate: (cssProperties?: ApiCssCustomProperty[]) => string;
+export declare const getPartsTemplate: (cssParts?: ApiCssPart[]) => string;
+export declare const getMethodsTemplate: (methods: ApiClassMember[]) => string;

package/dist/{manifests → docs}/webTypes/index.d.ts

@@ -1,5 +1,5 @@
-import type { ComponentManifest } from "../utils";
 import type { WebTypesOptions, WebTypesElement, WebTypes } from "./types";
+import { type ApiCustomElementDeclaration } from "@arcgis/api-extractor";
 /**
  * Originally based on
  * https://github.com/break-stuff/cem-tools/tree/main/packages/jet-brains-integration
@@ -16,5 +16,5 @@ import type { WebTypesOptions, WebTypesElement, WebTypes } from "./types";
  * - https://github.com/break-stuff/cem-tools/issues/141
  * - https://github.com/break-stuff/cem-tools/issues/112
  */
-export declare function generateWebTypes(components: ComponentManifest[], options: WebTypesOptions): WebTypes;
-export declare const getTagList: (components: ComponentManifest[], options: WebTypesOptions) => WebTypesElement[];
+export declare function generateWebTypes(components: ApiCustomElementDeclaration[], options: WebTypesOptions): WebTypes;
+export declare const getTagList: (components: ApiCustomElementDeclaration[]) => WebTypesElement[];

package/dist/{manifests → docs}/webTypes/types.d.ts

@@ -1,9 +1,6 @@
-import type { VsCodeReference } from "../vsCodeCustomData/types";
 export type WebTypesOptions = {
     /** @default "docs/web-types.json" */
     webTypesFileName?: string;
-    /** Used to create a link within the component info bubble */
-    referenceTemplate?: (name: string, tag: string) => Pick<VsCodeReference, "url">;
     /** Adds an icon link to the web-types.json **/
     defaultIcon?: string;
 };

package/dist/docs/webTypes/utils.d.ts

@@ -0,0 +1,6 @@
+import type { ApiCustomElementDeclaration } from "@arcgis/api-extractor";
+import type { WebTypesAttribute, WebTypesCssProperty, WebTypesPseudoElement } from "./types";
+export declare const getCssPropertyList: (components: ApiCustomElementDeclaration[]) => WebTypesCssProperty[];
+export declare const getCssPartList: (components: ApiCustomElementDeclaration[]) => WebTypesPseudoElement[];
+export declare const getComponentAttributes: (component: ApiCustomElementDeclaration) => WebTypesAttribute[];
+export declare const formatDescription: (description?: string, deprecated?: boolean | string) => string;

package/dist/entrypoints/config.d.ts

@@ -1,4 +1,3 @@
-import type { CompilerContext } from "../context";
 export declare const customElementEntrypointName = "customElement.js";
 export declare const customElementDtsFileName = "customElement.d.ts";
 export type CustomElementInterdependencies = Record<string, {
@@ -16,8 +15,4 @@ export type CustomElementInterdependencies = Record<string, {
     referencedTagNames: string[];
     readonly referencedBy: string[];
 }>;
-/**
- * This is used in build mode only.
- */
-export declare const customElementDependencies: WeakMap<CompilerContext, CustomElementInterdependencies>;
 export declare const defaultBrowserTestProvider = "playwright";

package/dist/entrypoints/dtsUtils.d.ts

@@ -1,5 +1,5 @@
 import type { DeclarationTextTransformer } from "../publicTypes";
-import { path } from "../utils/path";
+import { path } from "@arcgis/components-build-utils";
 import type { CompilerContext } from "../context";
 export declare const rewriteDtsComponentFileNames: DeclarationTextTransformer;
 export declare const rePath: RegExp;
@@ -11,7 +11,7 @@ export declare const rePath: RegExp;
  * Assuming content includes POSIX paths only (as that's what import specifiers
  * in ECMAScript use)
  */
-export declare const rewriteComponentImportSpecifiers: (code: string, context: Pick<CompilerContext, "componentPathMapping" | "dir">, cwd: string, originalCwd: string) => string;
+export declare const rewriteComponentImportSpecifiers: (code: string, context: Pick<CompilerContext, "_componentPathMapping" | "dir">, cwd: string, originalCwd: string) => string;
 /**
  * The result of relative() is a path that does not start with `./`.
  * In import statements the path must begin with ../ or ./ to be interpreted as

package/dist/entrypoints/pathMapping.d.ts

@@ -1,5 +1,4 @@
 import type { CompilerContext } from "../context";
-import type { ComponentManifest } from "../manifests/utils";
 /**
  * A mapping between a path to a component folder in src/components and it's
  * tag name.
@@ -20,6 +19,6 @@ import type { ComponentManifest } from "../manifests/utils";
 export type ComponentPathMapping = Record<string, PathMappingInterface | string>;
 interface PathMappingInterface extends ComponentPathMapping {
 }
-export declare function addComponentPathMapping(component: ComponentManifest, context: CompilerContext): string;
-export declare function renameComponentFolder(filePath: string, pathBase: string, context: Pick<CompilerContext, "componentPathMapping">): string;
+export declare function addComponentPathMapping(tagName: string, context: CompilerContext, sourcePath: string): string;
+export declare function renameComponentFolder(filePath: string, pathBase: string, context: Pick<CompilerContext, "_componentPathMapping">): string;
 export {};

package/dist/entrypoints/resolveTagName.d.ts

@@ -1,6 +1,5 @@
 import type { ResolvedDependencyComponent } from "../dependencies/discover";
-import type { ModulePath } from "../manifests/complexTypes/transformUtils";
-import type { ExtendedComponentManifest } from "../manifests/complexTypes/types";
+import type { ModulePath } from "../extractor/helpers/resolveType";
 import type { CompilerContext } from "../context";
 /**
  * Automatically add imports as appropriate for all referenced internally defined
@@ -8,7 +7,7 @@ import type { CompilerContext } from "../context";
  */
 export declare function resolveTagName(context: CompilerContext, tagName: string, fileName: string): ModulePath;
 export declare function modulePathToString(resolvedPath: ModulePath, distRelativeCwd: string): string;
-export declare function getLocalDefinedComponentsFromManifest(manifest: ExtendedComponentManifest): Readonly<Record<string, ResolvedDependencyComponent>>;
+export declare function getLocalDefinedComponentsFromApiJson(context: Pick<CompilerContext, "_localDefinedComponents" | "privateApiJson">): Readonly<Record<string, ResolvedDependencyComponent>>;
 export declare const exportsForTests: {
     modulePathToString: typeof modulePathToString;
 };

package/dist/extractor/apiJsonUtils.d.ts

@@ -0,0 +1,4 @@
+import type ts from "typescript";
+import type { ApiClassMethod, ApiCustomElementDeclaration, ApiCustomElementField, ApiJson, ApiModule } from "@arcgis/api-extractor";
+export declare function findMember(component: Pick<ApiCustomElementDeclaration, "members" | "name">, memberNode: ts.AccessorDeclaration | ts.MethodDeclaration | ts.PropertyDeclaration): ApiClassMethod | ApiCustomElementField | undefined;
+export declare function findApiModule(filePath: string, rootDir: string, apiJson: ApiJson): ApiModule | undefined;

package/dist/{manifests/customElementDecoratorPlugins.d.ts → extractor/declaration.d.ts}

@@ -34,25 +34,16 @@
  *
  * FEATURE: for usages in tests, allow `static override tagName = "te-st";` to define a component? and adapt transformers and plugins to look for nested components too when context.isInTest
  */
-import type { Plugin as ManifestPlugin } from "@custom-elements-manifest/analyzer";
+import ts from "typescript";
 import type { FileTransformer } from "../publicTypes";
-import type { CompilerContext } from "../context";
-/**
- * The manifest creation process is using ts.SourceFile instances created
- * by generateTypes() plugin rather than the transform() hooks (to have
- * access to the AST and types).
- * And, to make sure plugins can get access to the final manifest as soon as
- * possible, the manifest generation process is running before any file
- * transform().
- * At the same time, the manifest generation is not aware of our web
- * components because `@customElement()` decorators are not present yet
- * (will be added in transform() hook in vite plugin below). So we have to
- * manually augment "moduleDoc.exports" in this plugin, and later on add the
- * `@customElement()` decorator in the vite plugin.
- */
-export declare const addCustomElementDecoratorManifestPlugin: (context: CompilerContext) => ManifestPlugin;
+import type { DeclarationTextTransformer } from "../publicTypes";
+export declare const removeDeclarationFromDts: DeclarationTextTransformer;
 export declare const addCustomElementDecoratorTransformer: FileTransformer;
-export declare function findDeclaredComponents(code: string): (readonly [tagName: string, className: string])[] | undefined;
+export declare function findDeclaredComponentsInFile(file: ts.SourceFile): Map<string, string>;
+type DeclaredComponents = readonly (readonly [string, string])[];
+export declare function findDeclaredComponents(code: string): DeclaredComponents | undefined;
+export declare function validateTagName(tagName: string, className: string): void;
 export declare const exportsForTests: {
     findDeclaredComponents: typeof findDeclaredComponents;
 };
+export {};

package/dist/extractor/extractor.d.ts

@@ -0,0 +1,53 @@
+import ts from "typescript";
+import { ApiExtractor } from "@arcgis/api-extractor";
+import type { ApiAttribute, ApiClassMethod, ApiCustomElementDeclaration, ApiCustomElementField, ApiCustomElementMember, ApiDeclaration, ApiEvent, ApiExport, ApiJson, ApiModule } from "@arcgis/api-extractor";
+import type { CompilerContext } from "../context";
+export declare class LuminaApiExtractor extends ApiExtractor {
+    context: CompilerContext;
+    protected isPathOnly: boolean;
+    constructor(context: CompilerContext, isPathOnly: boolean);
+    protected localCssImports?: Set<string>;
+    protected localDeclaredComponents: Map<string, string>;
+    protected componentHtmlTypes: Map<string, string>;
+    protected apiComponent: ApiCustomElementDeclaration;
+    protected pairedSetter: ts.SetAccessorDeclaration | undefined;
+    extract(files: readonly ts.SourceFile[]): ApiJson;
+    protected extractModules(files: readonly ts.SourceFile[]): ApiModule[];
+    protected extractDeclarations(module: ts.SourceFile): ApiDeclaration[];
+    protected extractDeclaration(statement: ts.Statement): ApiDeclaration | undefined;
+    protected collectCssImports(node: ts.ImportDeclaration): void;
+    protected extractComponentDeclaration(node: ts.ClassDeclaration): ApiCustomElementDeclaration | undefined;
+    protected extractComponentMembers(node: ts.ClassDeclaration): ApiCustomElementMember[];
+    protected extractComponentMember(node: ts.ClassElement, name: string | undefined): ApiCustomElementMember | undefined;
+    protected extractComponentField(node: ts.AccessorDeclaration | ts.PropertyDeclaration, name: string): ApiCustomElementField | undefined;
+    /**
+     * Based on a `non-@property()` property, extract a public event if it is one.
+     */
+    protected extractComponentEvent(node: ts.PropertyDeclaration, name: string): ApiEvent | undefined;
+    /**
+     * When doing full API extraction, extract additional details for a field.
+     */
+    protected extractComponentFieldDetails(node: ts.AccessorDeclaration | ts.PropertyDeclaration, property: ApiCustomElementField): void;
+    /**
+     * Find the properties given to the `@property()` decorator.
+     */
+    protected findPropertyOptions(member: ts.AccessorDeclaration | ts.PropertyDeclaration): readonly ts.ObjectLiteralElementLike[] | undefined;
+    protected extractComponentMethod(node: ts.MethodDeclaration, name: string): ApiClassMethod | undefined;
+    /**
+     * Infer attributes based on public component members.
+     */
+    protected inferAttributes(members: ApiCustomElementMember[]): ApiAttribute[];
+    protected inferExport(declaration: ApiDeclaration): ApiExport | undefined;
+    protected inferCustomElementExport(declaration: ApiCustomElementDeclaration): ApiExport;
+    /**
+     * Inherit public members from a superclass. For this to work, the superclass
+     * needs to be in a a file named like a component
+     * (src/components/name/name.tsx), even if it is not a standalone component.
+     */
+    protected inheritMembers(component: ApiCustomElementDeclaration, modules: ApiModule[], existingMembers?: Set<string>, existingAttributes?: Set<string>, existingEvents?: Set<string>): void;
+    private _resolvedInheritance;
+    /**
+     * Based on the superclass name, find the actual declaration in the modules.
+     */
+    protected resolveInheritance(superClassName: string, modules: ApiModule[]): ApiCustomElementDeclaration | undefined;
+}