@arcgis/lumina-compiler 4.32.0-next.7 → 4.32.0-next.71

package/dist/context/index.d.ts

@@ -1,87 +1,136 @@
 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 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
      */
-    private _typeScriptSourceFiles;
+    _typeScriptReload?: Deferred<void>;
     /**
      * Whether minification is enabled for transformed JSX (lit-html templates)
      * and generated component code.
      */
     shouldMinify: boolean;
     /**
-     * Like this.shouldMinifyStrict, but true when in test mode. Reasons:
+     * Like this.shouldMinify, but true when in test mode. Reasons:
      * - If accessing .textContent, the whitespace amount differs between minified
      *   and non-minified lit-html templates. In Stencil's JSX this was not the
      *   case. To ease migration of tests, we minify lit-html in tests too.
      * - From the above, you can see that minification does change semantics in
      *   some cases. To have tests be truer to the real world, we minify in tests.
+     *
+     * Also, true during build as per
+     * https://devtopia.esri.com/WebGIS/arcgis-web-components/issues/2084
      */
-    shouldMinifyStrict: boolean;
+    shouldMinifyJsx: boolean;
     /**
      *
      * 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
-     *
-     * Stores information about the structure of all components in the package
-     * (their properties, methods, events, JSDoc and etc).
+     * The api.json 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 +198,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 +213,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 +237,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 +255,75 @@ 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.
+     *
+     * @private
+     */
+    _compilerOptionsForPrinter: ReturnType<typeof getCompilerOptionsForPrinter>;
+    /**
+     * Cached result of getPrinter() call. Cached to not needlessly create and
+     * throw away a printer instance for each transformed file.
+     *
+     * @private
+     */
+    _typeScriptPrinter: ReturnType<typeof getPrinter>;
+    /**
+     * Cached RegExp for replacing occurrences of `ArcgisCounter["el"]` with
+     * `HtmlElementArcgisCounter`.
+     *
+     * @private
+     */
+    _htmlElementReferencesReplacer?: {
+        regex: RegExp;
+        replacements: Record<string, string>;
+    };
+    /**
+     * Mapping between component tag name and public properties in that component
+     * whose type depends on another property.
+     *
+     * @private
+     */
+    _typeDependencies: Map<string, Set<string>>;
+    private _silencedRules;
+    /**
+     * Promise that resolves once src/lumina.ts is updated
+     * @private
+     */
+    _updateLuminaTsPromise?: Promise<void>;
     constructor(options: LuminaOptions);
     private _inferBuildSetup;
     /**
@@ -247,4 +360,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, withSourceMap: boolean): 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("@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/index.d.ts

@@ -10,3 +10,4 @@ export declare const doLoadersApply: (context: CompilerContext, htmlContext?: In
  *
  */
 export declare const provideDependencySupport: (context: CompilerContext) => Plugin;
+export declare const luminaTsUpdatedMessage: string;

package/dist/dependencies/updateLumina.d.ts

@@ -1,6 +1,6 @@
 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("@arcgis/components-build-utils").MiniPackageJson): Promise<void>;
+export declare function updateLuminaTs(dependencies: readonly ResolvedDependencyComponents[], srcDir: string, hasCore: boolean, browserProvider?: BrowserConfigOptions["provider"], packageJson?: import("@arcgis/components-build-utils").MiniPackageJson): Promise<boolean>;
 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/docs/stencilDocsJson.d.ts

@@ -0,0 +1,125 @@
+import type { ComponentCompilerTypeReferences } from "@stencil/core/internal";
+import type { CompilerContext } from "../context";
+import { type ApiDocsTag } from "@arcgis/api-extractor";
+/**
+ * To avoid having a dependency on Stencil, we inline Stencil types rather than
+ * importing them.
+ */
+export interface JsonDocs {
+    components: JsonDocsComponent[];
+    timestamp: string;
+    compiler: {
+        name: string;
+        version: string;
+        typescriptVersion: string;
+    };
+    typeLibrary: Record<string, never>;
+}
+interface JsonDocsComponent {
+    filePath?: string;
+    encapsulation: "none" | "scoped" | "shadow";
+    tag: string;
+    readme: string;
+    docs: string;
+    docsTags: ApiDocsTag[];
+    overview?: string;
+    usage: Record<string, string>;
+    props: JsonDocsProp[];
+    methods: JsonDocsMethod[];
+    events: JsonDocsEvent[];
+    listeners: never[];
+    styles: {
+        name: string;
+        docs: string;
+        annotation: string;
+        mode: string | undefined;
+    }[];
+    slots: {
+        name: string;
+        docs: string;
+    }[];
+    parts: {
+        name: string;
+        docs: string;
+    }[];
+    dependents: string[];
+    dependencies: string[];
+    dependencyGraph: Record<string, never>;
+    deprecation?: string;
+}
+interface JsonDocsEvent {
+    event: string;
+    bubbles: boolean;
+    cancelable: boolean;
+    composed: boolean;
+    complexType: ComplexType;
+    docs: string;
+    docsTags: ApiDocsTag[];
+    deprecation?: string;
+    detail: string;
+}
+interface ComponentCompilerMethodComplexType {
+    signature: string;
+    parameters: {
+        name: string;
+        type: string;
+        docs: string;
+    }[];
+    references: ComponentCompilerTypeReferences;
+    return: string;
+}
+interface JsonDocsMethod {
+    name: string;
+    docs: string;
+    docsTags: ApiDocsTag[];
+    deprecation?: string;
+    signature: string;
+    returns: {
+        type: string;
+        docs: string;
+    };
+    parameters: ComponentCompilerMethodComplexType["parameters"];
+    complexType: ComponentCompilerMethodComplexType;
+}
+interface ComplexType {
+    original: string;
+    resolved: string;
+    references: ComponentCompilerTypeReferences;
+}
+export interface JsonDocsProp {
+    name: string;
+    complexType?: ComplexType;
+    type: string;
+    mutable: boolean;
+    attr?: string;
+    reflectToAttr: boolean;
+    docs: string;
+    docsTags: ApiDocsTag[];
+    default?: string;
+    deprecation?: string;
+    values: {
+        value?: string;
+        type: string;
+    }[];
+    optional: boolean;
+    required: boolean;
+}
+/**
+ * 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.
+ * Since they are similar in content, generating a Stencil-compatible docs.json
+ * will smooth the migration path.
+ *
+ * REFACTOR: drop support for stencil compatible docs.json at some point
+ *
+ * @remarks
+ * To make it easier for people to diff the docs.json before and after migration
+ * to Lit, we make sure that the order of properties matches what Stencil
+ * generates:
+ * https://github.com/ionic-team/stencil/blob/9f5f9cdd023b8c8dfb5417a1a970605ba724ae28/src/compiler/docs/generate-doc-data.ts#L98
+ */
+export declare const generateStencilDocsJson: (context: CompilerContext) => JsonDocs;
+export {};

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

@@ -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 {};