@arcgis/lumina-compiler 4.31.0-next.100

package/LICENSE.md

@@ -0,0 +1,13 @@
+# Licensing
+
+COPYRIGHT © 2024 Esri
+
+All rights reserved under the copyright laws of the United States and applicable international laws, treaties, and conventions.
+
+This material is licensed for use under the Esri Master License Agreement (MLA), and is bound by the terms of that agreement. You may redistribute and use this code without modification, provided you adhere to the terms of the MLA and include this copyright notice.
+
+See use restrictions at http://www.esri.com/legal/pdfs/mla_e204_e300/english
+
+For additional information, contact: Environmental Systems Research Institute, Inc. Attn: Contracts and Legal Services Department 380 New York Street Redlands, California, USA 92373 USA
+
+email: contracts@esri.com

package/README.md

@@ -0,0 +1,21 @@
+# ArcGIS Maps SDK for JavaScript - Lit
+
+**No Esri Technical Support included.**
+
+Package that is part of the [ArcGIS Maps SDK for JavaScript](https://developers.arcgis.com/javascript).
+
+It is not intended to be used directly, but rather used as a dependency by other packages in the SDK.
+
+## License
+
+COPYRIGHT © 2024 Esri
+
+All rights reserved under the copyright laws of the United States and applicable international laws, treaties, and conventions.
+
+This material is licensed for use under the Esri Master License Agreement (MLA), and is bound by the terms of that agreement. You may redistribute and use this code without modification, provided you adhere to the terms of the MLA and include this copyright notice.
+
+See use restrictions at <http://www.esri.com/legal/pdfs/mla_e204_e300/english>
+
+For additional information, contact: Environmental Systems Research Institute, Inc. Attn: Contracts and Legal Services Department 380 New York Street Redlands, California, USA 92373 USA
+
+email: contracts@esri.com

package/dist/chunk-BQ4U6HQL.js

@@ -0,0 +1 @@
+import{sep as i}from"path";import o from"path/posix";import r from"path/win32";var n=i===o.sep,e=s=>s.includes(r.sep)?s.replaceAll(r.sep,o.sep):s,c=s=>s.includes(o.sep)?s.replaceAll(o.sep,r.sep):s,u=n?s=>s:c,m=n?process.cwd:()=>e(process.cwd()),x=n?o:{...r,sep:o.sep,join(...s){let t=r.join(...s);return e(t)},normalize(s){let t=r.normalize(s);return e(t)},relative(s,t){let p=r.relative(s,t);return e(p)},dirname(s){let t=r.dirname(s);return e(t)},resolve(...s){let t=r.resolve(...s);return e(t)},toNamespacedPath(s){let t=r.toNamespacedPath(s);return e(t)}};export{n as a,e as b,u as c,m as d,x as e};

package/dist/chunk-JFKSI6I7.js

@@ -0,0 +1 @@
+var h=Object.defineProperty;var i=Object.getOwnPropertyDescriptor;var j=(g,b,d,c)=>{for(var a=c>1?void 0:c?i(b,d):b,e=g.length-1,f;e>=0;e--)(f=g[e])&&(a=(c?f(b,d,a):f(a))||a);return c&&a&&h(b,d,a),a};export{j as a};

package/dist/context/index.d.ts

@@ -0,0 +1,241 @@
+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 { ComponentPathMapping } from "../entrypoints/pathMapping";
+import type { ManifestType } from "../manifests/types";
+import type { ComponentManifest } from "../manifests/utils";
+import type { ContextDirectories } from "./types";
+export declare class CompilerContext {
+    /**
+     * The path to a resolved TypeScript config file
+     */
+    readonly typeScriptConfigPath: string;
+    /**
+     * The resolved TypeScript config file
+     */
+    readonly typeScriptConfig: ts.ParsedCommandLine;
+    /**
+     * An instance of TypeScript program. Contains all .tsx source files present
+     * in the project
+     *
+     * TypeScript program is created only in build mode, not in serve
+     */
+    typeScriptProgram?: ts.Program;
+    /**
+     * An instance of TypeScript type checker
+     *
+     * TypeScript type checker is created only in build mode, not in serve
+     */
+    typeScriptTypeChecker?: ts.TypeChecker;
+    /**
+     * An instance of TypeScript compiler host
+     */
+    typeScriptHost: ts.CompilerHost;
+    /**
+     * TypeScript source file instances created in serve mode
+     */
+    private _typeScriptSourceFiles;
+    /**
+     * Whether minification is enabled for transformed JSX (lit-html templates)
+     * and generated component code
+     */
+    shouldMinify: boolean;
+    /**
+     *
+     * A vite plugin that sets the initial context information based on Vite
+     * environment
+     *
+     * @internal
+     */
+    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).
+     *
+     * You can augment the manifest generation using the `manifest` option on
+     * `useLumina()`
+     *
+     * @see https://custom-elements-manifest.open-wc.org/analyzer/getting-started/
+     */
+    manifest: ExtendedComponentManifest;
+    /**
+     * A flattened custom-element-manifest listing all components in this package.
+     */
+    manifestComponents: ComponentManifest[];
+    /**
+     * @internal
+     */
+    componentPathMapping: ComponentPathMapping;
+    /**
+     * The environment that Vite is running in
+     *
+     * By default, `npx vite` will run in `development` mode. and `npx vite build`
+     * will run in `production` mode. However, you can do a development-mode build
+     * using `npx vite build --mode development`
+     *
+     * - By default, source maps are generated only in development builds.
+     * - Minification happens in production builds.
+     */
+    environment: "development" | "production";
+    /**
+     * It is a best practice to keep local build behavior as similar as possible
+     * to CI build. Thus, only use this option if some behavior really
+     * needs to be different in the CI.
+     *
+     * For example, `@arcgis/lumina-compiler` will by default automatically update
+     * your package's package.json if it is missing some properties. However, this
+     * behavior is disabled on the CI machine.
+     *
+     * @default Boolean(process.env.CI)
+     */
+    readonly isInCi: boolean;
+    /**
+     * It is a best practice to keep production behavior as similar as possible
+     * to test environment. Thus, only use this option if some behavior really
+     * needs to be different in test environment.
+     *
+     * For example, `@arcgis/lumina-compiler` will by default automatically update
+     * your package's package.json if it is missing some properties. However, this
+     * behavior is disabled in test environment.
+     *
+     * Test environment is detected in the following cases:
+     * - Running in test mode (`npx vite build --mode test`). In such case
+     *   CompilerContext.environment will still be set to `development`
+     * - Running in vitest - a test runner for Vite (`npx vitest`)
+     * - Running vitest performance benchmark (`npx vitest benchmark`)
+     */
+    isInTest: boolean;
+    /**
+     * If running inside of Vitest as part of Puppeteer test integration
+     */
+    isInPuppeteerTestBackEnd: boolean;
+    /**
+     * If running in a Vite instance created by Vitest Puppeteer integration.
+     */
+    isInPuppeteerTestFrontEnd: boolean;
+    /**
+     * Whether Vite build/serve is running inside of Storybook.
+     */
+    isInStorybook: boolean;
+    /**
+     * Whether HMR is enabled during the current Vite run
+     */
+    hmrEnabled: boolean;
+    /**
+     * Vite can be run in two modes:
+     * - Serve the project (with watching for changes and hot module reloading).
+     *   This is the case when you run Vite as `npx vite`
+     * - Build the project (with bundling and optimizations).
+     *   This is the case when you run Vite as `npx vite build`
+     *
+     * `@arcgis/lumina-compiler` does not know what environment Vite is running
+     * in until the `apply()` Vite plugin hook is called by Vite. That means, you
+     * should not try to read this property before the `apply()` hook is called.
+     */
+    viteCommand: ConfigEnv["command"];
+    readonly banner: string;
+    /**
+     * `@arcgis/lumina-compiler` plugins may register additional `.d.ts`
+     * transformers. For public consumption of Lumina, instead of using this
+     * option, use the `types.declarationTextTransformers` option on the
+     * `useLumina` Vite plugin.
+     *
+     * @internal
+     */
+    readonly declarationTextTransformers: DeclarationTextTransformer[];
+    /**
+     * Options passed to `useLumina()`
+     */
+    options: LuminaOptions;
+    /**
+     * Resolved file names for documentation files
+     *
+     * @internal
+     */
+    documentationFileNames: Record<ManifestType, string>;
+    /**
+     * Resolved Vite configuration
+     */
+    viteConfig: ResolvedConfig;
+    /**
+     * Vite's dev server. Set only if Vite is running in serve mode
+     */
+    server: ViteDevServer;
+    /**
+     * Whether configServer() hook has already been called
+     *
+     * @internal
+     */
+    serverConfigured: boolean;
+    /**
+     * Assets pending to be served
+     *
+     * @internal
+     */
+    assetsToProvide: ProvideAssetsOptions[] | undefined;
+    /**
+     * A promise that resolves to list of file names that declare one or more
+     * components
+     */
+    componentFilesPromise: Promise<string[]>;
+    /**
+     * Style for hiding custom elements before they are loaded. This is appended
+     * to the global stylesheet.
+     *
+     * @internal
+     */
+    globalHydratedCssString: string;
+    /**
+     * Contents of the bundled global CSS file
+     *
+     * @internal
+     */
+    globalCssString?: string;
+    /**
+     * A list of file names that declare one or more components
+     */
+    componentFiles: string[];
+    constructor(options: LuminaOptions);
+    private _inferBuildSetup;
+    /**
+     * Get TypeScript ts.SourceFile based on file name and code. Reuses existing
+     * source file instance if already created one for that file, and code has not
+     * changed.
+     */
+    getSourceFile(fileName: string, code: string): ts.SourceFile;
+    /**
+     * A utility for making Vite copy assets to the output folder during build or
+     * making Vite serve them when running in serve mode
+     *
+     * @example
+     * ```ts
+     * // vite.config.ts
+     * import { defineConfig } from "vite";
+     * import { useLumina } from "@arcgis/lumina-compiler";
+     *
+     * export default defineConfig((env) => {
+     *   const lumina = useLumina();
+     *
+     *   lumina.context.provideAssets([
+     *     {
+     *       type: "dynamic",
+     *       source: () => new Date().toString(),
+     *       destination: "build_date.txt",
+     *     },
+     *   ]);
+     *
+     *   return {
+     *     plugins: [lumina],
+     *   };
+     * });
+     * ```
+     */
+    provideAssets(assets: AssetSpec[], transformers?: AssetTransformer[], apply?: CompilerContext["viteCommand"]): void;
+}

package/dist/context/types.d.ts

@@ -0,0 +1,34 @@
+export type ContextDirectories = {
+    /**
+     * The project root directory. Usually equals to process.cwd() + '/'
+     */
+    root: string;
+    /**
+     * The source directory. Usually equals dir.root + `src/`
+     */
+    src: string;
+    /**
+     * The components directory. Usually equals dir.src + `components/`
+     */
+    srcComponents: string;
+    /**
+     * The root-relative path to the dist directory. Usually 'dist/'
+     */
+    relativeDist: string;
+    /**
+     * The output directory. Usually equals dir.root + `dist/`
+     */
+    dist: string;
+    /**
+     * The CDN output directory. Usually equals dir.output + `cdn/`
+     */
+    distCdn: string;
+    /**
+     * The components output directory. Usually equals dir.output + `components/`
+     */
+    distComponents: string;
+    /**
+     * The assets output directory. Usually equals dir.output + `cdn/assets/`
+     */
+    distCdnAssets: string;
+};

package/dist/context/utils.d.ts

@@ -0,0 +1,23 @@
+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 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/context/utils.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/defaultAssetsUrl.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Generates a URL like this from the provided package json:
+ * `https://js.arcgis.com/<simplified-package-name>/<released-verion>/`
+ *
+ * @example
+ * `https://js.arcgis.com/map-components/4.30/`
+ *
+ * @remarks
+ * If package version number includes "next", `jsdev.arcgis.com` CDN is used
+ * instead of `js.arcgis.com`.
+ */
+export declare function inferCdnUrl(packageJson?: {
+    name: string;
+    version: string;
+}, preferNext?: boolean, 
+/**
+ * Whether to include the patch semver component in the URL (1.1.x <- the x)
+ *
+ * @default false, unless packageJson.name is `@esri/calcite-components`
+ */
+includePatch?: boolean): string;

package/dist/defaultAssetsUrl.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/dependencies/arcgisCore.d.ts

@@ -0,0 +1,30 @@
+import { type DependencyInjectionMode, type DependencyInjectionResult } from "./utils";
+export declare const hasCore: boolean;
+/**
+ * Thanks to Vite's dependency pre-bundling, we do not have to use the CDN
+ * during local development, but can instead consume the pre-bundled
+ * `@arcgis/core` from the node_modules directory.
+ *
+ * This has benefits:
+ * - using the ESM CDN involves making a lot of network requests, often for
+ *   small files. With pre-bundling, performance can be improved
+ * - by using `@arcgis/core` from node_modules, the dev server is guaranteed to
+ *   use the version of `@arcgis/core` that the package.json specifies. Where as
+ *   the CDN could be out of date, or point to `next` (which is somewhat
+ *   ambiguous around release time)
+ * - by using `@arcgis/core` from node_modules, you can edit the package in
+ *   node_modules to quickly preview the result of your edits. This is useful
+ *   if you are debugging a bug and not yet sure if the bug is with your package
+ *   or with `@arcgis/core`. More on this:
+ *   https://vitejs.dev/guide/dep-pre-bundling#browser-cache
+ *
+ * In builds, all dependencies are externalized so this is not a concern.
+ *
+ * In storybook builds, we use the ESM CDN. Reasons:
+ * - dependency pre-bundling is not available in build mode, only in serve mode
+ * - bundling `@arcgis/core` makes the build output huge, creating logistical
+ *   challenges around deploying many preview branches
+ * - for external users, having both storybook and docs use the ESM CDN means
+ *   they benefit from caching the ESM CDN across both sites
+ */
+export declare function produceArcgisCoreTags(baseUrl: string, mode: DependencyInjectionMode): Promise<DependencyInjectionResult[]>;

package/dist/dependencies/discover.d.ts

@@ -0,0 +1,62 @@
+import type { Package } from "custom-elements-manifest/schema";
+import type { WebTypesJson } from "../jsxToLitHtml/types";
+import type { ModulePath } from "../manifests/complexTypes/transformUtils";
+export type ResolvedDependencyComponents = {
+    readonly packageName: string;
+    readonly type: "@arcgis/lumina" | "stencil" | "unknown";
+    readonly components: Readonly<Record<string, ResolvedDependencyComponent>>;
+};
+export type ResolvedDependencyComponent = ModulePath & {
+    /**
+     * If jsx property has a static value, and we see that an equivalent attribute
+     * exists, jsx property will be converted to an attribute rather than
+     * property. If we failed to read all attributes from a package, it's not a
+     * big deal as we will then play safe and leave jsx properties as properties.
+     */
+    readonly propToAttribute: Readonly<Record<string, string>>;
+};
+/**
+ * Read information about our web component dependencies. This will be used to:
+ * - know where to auto-import a component from
+ * - detect usages of unknown components
+ * - convert properties to attributes (JSX is authored using property names, not
+ *   attribute names, but if property is assigned a static value, setting it as
+ *   an attribute is better for performance)
+ *   - I was hoping lit-html would allow this syntax to set a property:
+ *     .property="staticValue", but no, static values are only allowed for
+ *     attributes. For static parts of the template, Lit would just copy them
+ *     from the compiled template without any processing, keeping initial render
+ *     and re-render fast.
+ *     - Benchmark: setting static attributes: 3.7s (dev), 3.2s (production)
+ *       setting properties that don't change: 5.1s (dev) and 3.3s (production)
+ *       - negligible difference in production
+ *   - Seeing the attribute in HTML would make for easier debugging
+ *
+ * Process:
+ * - For each peer and dev dependency:
+ *   - If it has manifest.json, 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
+ *   - Else, if has dist/components/*.d.ts, read from there (Stencil in dev
+ *     mode and many non-Stencil libraries)
+ *
+ * If this does not work for one of your dependencies, provide a custom resolver
+ * to autoAddImports() or useLumina().
+ */
+export declare function initializeComponentDependencies(cwd?: string): Promise<readonly ResolvedDependencyComponents[]>;
+export declare function retrieveComponentDependencies(): readonly ResolvedDependencyComponents[];
+export declare function retrieveFlatComponentDependencies(): ResolvedDependencyComponents["components"];
+export declare let componentDependenciesPromise: Promise<readonly ResolvedDependencyComponents[]> | undefined;
+export declare function findPackageComponents(packageName: string, cwd?: string): Promise<ResolvedDependencyComponents | undefined>;
+/**
+ * Given the custom element manifest, find custom elements defined in it
+ */
+export declare const manifestToDependencyComponents: (manifest: Package, dependency: Omit<ModulePath, "moduleName"> & {
+    readonly getImportPath: (tagName: string) => string;
+}) => ResolvedDependencyComponents["components"];
+export declare const webTypesToDependencyComponents: (webTypes: WebTypesJson, dependency: Omit<ModulePath, "moduleName"> & {
+    readonly packageRoot: string | undefined;
+    readonly getImportPath: (tagName: string) => string;
+}) => ResolvedDependencyComponents["components"];
+export declare const inferDependencyComponentModuleName: (usesExports: boolean, tagName: string) => string;

package/dist/dependencies/index.d.ts

@@ -0,0 +1,11 @@
+import type { Plugin } from "vite";
+import type { CompilerContext } from "../context";
+/**
+ * In serve mode, augment index.html by adding the necessary script tags for
+ * each web component dependency.
+ *
+ * In case of Storybook, we apply this plugin to iframe.html, not just in serve
+ * mode, but also in build mode.
+ *
+ */
+export declare const provideDependencySupport: (context: CompilerContext) => Plugin;

package/dist/dependencies/lit.d.ts

@@ -0,0 +1,2 @@
+import { type DependencyInjectionMode, type DependencyInjectionResult } from "./utils";
+export declare function makeLitLoader(baseUrl: string, packageName: string, mode: DependencyInjectionMode, index: number): Promise<DependencyInjectionResult>;

package/dist/dependencies/loaders.d.ts

@@ -0,0 +1,8 @@
+import type { CompilerContext } from "../context";
+import { type ResolvedDependencyComponents } from "./discover";
+import type { DependencyInjectionResult } from "./utils";
+export declare const serveOnlyDependencies: WeakMap<CompilerContext, Promise<readonly ResolvedDependencyComponents[]>>;
+export declare function makeLoaders(context: CompilerContext): Promise<DependencyInjectionResult[]>;
+export declare const silenceLitWarnings: {
+    javascriptCode: string[];
+};

package/dist/dependencies/stencil.d.ts

@@ -0,0 +1,6 @@
+import { type DependencyInjectionMode, type DependencyInjectionResult } from "./utils";
+export declare function makeStencilLoader(baseUrl: string, packageName: string, mode: DependencyInjectionMode, index: number): Promise<DependencyInjectionResult[]>;
+export declare function findCdnFiles(distDirectory: string): Promise<{
+    readonly cdnName: string;
+    readonly hasCss: boolean;
+} | undefined>;

package/dist/dependencies/testSetupFiles.d.ts

@@ -0,0 +1,21 @@
+import type { CompilerContext } from "../context";
+export declare const testLitSetupFileName = "/@arcgis/lumina-compiler/testLitSetupFile";
+/**
+ * For browser tests, this file lazy-loads all dependencies, and then the
+ * current package itself.
+ * It also does misc test setup logic (mocking console, setting timeouts,
+ * etc).
+ */
+export declare const testSetupFileName = "/@arcgis/lumina-compiler/testSetupFile";
+export declare const testSetupFileNames: string[];
+export declare const litTestSetupFileContent: string;
+/**
+ * Get the entrypoint code for lazy-loading all components and their
+ * dependencies when running a web component test in the browser.
+ *
+ * Lazy loading is critical for performance. Since each test runs in isolation,
+ * we wouldn't want to load all possible components in each test (and tracking
+ * precisely which components were used is tricky and bug prone - i.e won't
+ * catch dynamic references).
+ */
+export declare function buildTestSetupFile(context: CompilerContext): Promise<string>;

package/dist/dependencies/updateLumina.d.ts

@@ -0,0 +1,8 @@
+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"]): Promise<void>;
+declare function produceLuminaTs(dependencies: readonly ResolvedDependencyComponents[], hasCore: boolean, browserProvider?: BrowserConfigOptions["provider"], packageJson?: import("../utils/packageJson").MiniPackageJson): string;
+export declare const exportsForTests: {
+    produceLuminaTs: typeof produceLuminaTs;
+};
+export {};

package/dist/dependencies/updateLumina.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/dependencies/utils.d.ts

@@ -0,0 +1,23 @@
+import type { HtmlTagDescriptor } from "vite";
+export type DependencyInjectionMode = "lazy" | "storybookBuild";
+export type DependencyInjectionResult = HtmlTagDescriptor | {
+    cssHref: string;
+    id?: string;
+} | {
+    javascriptCode: string[];
+};
+/**
+ * Convert a path like C:/Users/test into /C:/Users/test
+ *
+ * Leaves posix paths unchanged
+ *
+ * Mirrors what Vite does:
+ * https://github.com/vitejs/vite/blob/564c8f45f5429bd149b441d7dca4f44347dedfb1/packages/vite/src/node/server/warmup.ts#L66
+ */
+export declare const absolutePathToUrl: (absolutePath: string) => string;
+/**
+ * The `baseUrl` should be set to `context.viteConfig.base`
+ * Vite always normalized `base` to end with `/`, and, if in serve mode, to not
+ * include domain name
+ */
+export declare const toFsUrl: (baseUrl: string, absolutePath: string) => string;

package/dist/entrypoints/addNonLazyImports.d.ts

@@ -0,0 +1,13 @@
+import type { Plugin } from "vite";
+import type { CompilerContext } from "../context";
+/**
+ * When component is imported in a non-lazy-loading way, we need to make sure
+ * the component file has explicit import statements for all web component it
+ * depends on - this ensures dependencies get bundled correctly.
+ *
+ * However, in lazy-loading mode, we don't need to do this because all dependent
+ * components are assumed to be lazy-loadable too.
+ *
+ * This plugin creates an index.js for each component for non-lazy-loading mode.
+ */
+export declare const addNonLazyImports: (context: CompilerContext) => Plugin;

package/dist/entrypoints/config.d.ts

@@ -0,0 +1,23 @@
+import type { CompilerContext } from "../context";
+export declare const customElementEntrypointName = "customElement.js";
+export declare const customElementDtsFileName = "customElement.d.ts";
+export type CustomElementInterdependencies = Record<string, {
+    /**
+     * All local or foreign custom elements referenced in current file.
+     *
+     * If this is a component entrypoint file, these imports will be added to
+     * the component-name/index.js file so that non-lazy esm usages would
+     * include this import.
+     * If this is not an entrypoint file (i.e a util functional component), then
+     * the referencedBy array will be used to find the entrypoint files that
+     * referenced this file (directly or indirectly), and any import specifiers
+     * will be added to those components instead of this file.
+     */
+    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

@@ -0,0 +1,22 @@
+import type { DeclarationTextTransformer } from "../publicTypes";
+import { path } from "../utils/path";
+import type { CompilerContext } from "../context";
+export declare const rewriteDtsComponentFileNames: DeclarationTextTransformer;
+export declare const rePath: RegExp;
+/**
+ * Rewrite references to `./components/component-folder-name/component-file-name.js` with
+ * `./components/component-tag-name/customElement.js` in `.js` and `.d.ts` files.
+ *
+ * @remarks
+ * 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;
+/**
+ * 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
+ * a relative path rather than a package name.
+ * This function makes sure that the result of relative() is normalized to start
+ * with `./` or `../`
+ */
+export declare const toRelativeImportSpecifier: (typeof path)["relative"];

package/dist/entrypoints/dtsUtils.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/entrypoints/findUtils.d.ts

@@ -0,0 +1,21 @@
+import type { CompilerContext } from "../context";
+/**
+ * Create a separate entrypoint for each component to allow consuming
+ * applications to only load the necessary code.
+ *
+ * @remarks
+ * Finds all components in the src/components folder. With support for nested
+ * components (looking for .tsx files whose name matches their folder name)
+ */
+export declare const getComponentEntrypoints: (context: CompilerContext) => Promise<Readonly<Record<string, string>>>;
+/**
+ * @example
+ * `src/components/component-name/component-name.tsx` =>
+ * `./components/component-name/customElement`
+ */
+export declare const entrypointPathToDistPath: (sourceFileName: string, srcPath?: string) => string;
+export declare const findComponentFiles: (context: CompilerContext, componentsDirectory: string, searchBase?: string) => Promise<string[]>;
+/**
+ * Check if absolute file path looks like a component entrypoint
+ */
+export declare function pathIsEntrypoint(absolutePath: string, componentsFolder: string): boolean;

package/dist/entrypoints/findUtils.spec.d.ts

@@ -0,0 +1 @@
+export {};