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

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

@@ -1,43 +1,6 @@
 export type VsCodeDocOptions = {
-    /** @default "docs/vscode.html-custom-data.json" */
-    htmlFileName?: string;
-    /** @default "docs/vscode.css-custom-data.json" */
-    cssFileName?: string;
-};
-export type VsCodeHtmlDocs = {
-    $schema: string;
-    version: number;
-    tags: VsCodeTag[];
-};
-export type VsCodeCssDocs = {
-    $schema: string;
-    version: number;
-    properties: VsCodeCssProperty[];
-    pseudoElements: VsCodeCssProperty[];
-};
-export type VsCodeTag = {
-    name: string;
-    description?: string;
-    attributes?: VsCodeTagAttribute[];
-    references?: VsCodeReference[];
-};
-type VsCodeCssProperty = {
-    name: string;
-    description?: string;
-    values?: VsCodeValue[];
-    references?: VsCodeReference[];
-};
-export type VsCodeTagAttribute = {
-    name: string;
-    description?: string;
-    values?: VsCodeValue[];
-    references?: VsCodeReference[];
-};
-export type VsCodeValue = {
-    name: string;
-};
-type VsCodeReference = {
-    name: string;
-    url: string;
-};
-export {};
+  /** @default "docs/vscode.html-custom-data.json" */
+  htmlFileName?: string;
+  /** @default "docs/vscode.css-custom-data.json" */
+  cssFileName?: string;
+};

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

@@ -1,77 +1,6 @@
 export type WebTypesOptions = {
-    /** @default "docs/web-types.json" */
-    webTypesFileName?: string;
-    /** Adds an icon link to the web-types.json **/
-    defaultIcon?: string;
-};
-/**
- * "web-types.json" has TypeScript definitions, but those are in a package that
- * has a bunch of Vue dependencies, which we don't want. Opened an issue:
- * https://github.com/JetBrains/web-types/issues/83
- */
-export type WebTypes = {
-    ["$schema"]: string;
-    name: string;
-    version: string;
-    ["description-markup"]: "html" | "markdown" | "none";
-    ["default-icon"]?: string;
-    contributions?: {
-        html?: {
-            elements?: readonly WebTypesElement[];
-            tags?: readonly WebTypesElement[];
-        };
-        css?: {
-            properties?: WebTypesCssProperty[];
-            ["pseudo-elements"]?: WebTypesPseudoElement[];
-        };
-    };
-};
-export type WebTypesElement = {
-    name: string;
-    description: string;
-    ["doc-url"]?: string;
-    attributes: WebTypesAttribute[];
-    slots?: WebTypesSlot[];
-    js?: WebTypesJsProperties;
-};
-export type WebTypesAttribute = {
-    name: string;
-    description?: string;
-    default?: string;
-    value: WebTypesValue;
-    required?: boolean;
-};
-type WebTypesSlot = {
-    name?: string;
-    description?: string;
-};
-type WebTypesValue = {
-    type?: string[] | string;
-};
-type WebTypesJsProperties = {
-    properties: WebTypesJsProperty[];
-    events: WebTypesEvent[];
-};
-export type WebTypesJsProperty = {
-    name: string;
-    description?: string;
-    type?: string;
-    default?: string;
-};
-export type WebTypesEvent = {
-    name: string;
-    type?: string;
-    description?: string;
-};
-export type WebTypesPseudoElement = {
-    name: string;
-    description?: string;
-    docUrl?: string;
-    arguments?: boolean;
-    deprecated?: boolean;
-};
-export type WebTypesCssProperty = {
-    name: string;
-    description?: string;
-};
-export {};
+  /** @default "docs/web-types.json" */
+  webTypesFileName?: string;
+  /** Adds an icon link to the web-types.json */
+  defaultIcon?: string;
+};

package/dist/index.d.ts

@@ -1,25 +1,25 @@
-import { initializeComponentDependencies } from './dependencies/discover.ts';
-import { updateLuminaTs } from './dependencies/updateLumina.ts';
-export { useLumina } from './useLumina.ts';
-export type * from './publicTypes.ts';
-export { inferCdnUrl } from './defaultAssetsUrl.ts';
-export type { CompilerContext } from './context/index.ts';
+import type { initializeComponentDependencies } from "./dependencies/discover.js";
+import type { updateLuminaTs } from "./dependencies/updateLumina.js";
+import type { alwaysAttributes, htmlAlwaysAttributes, mathMlElements, nativeAlwaysAttributes, nativeEvents, propertyToAttributeMappings, svgElements } from "./jsxToLitHtml/config.js";
+
+export { useLumina } from "./useLumina.js";
+export type * from "./options.js";
+export { inferCdnUrl } from "./defaultAssetsUrl.js";
+export { type CompilerContext } from "./context/index.js";
+
 /**
- * These are exposed only for usage by the @arcgis/stencil-to-lumina codemod
+ * These are exposed only for usage by the \@arcgis/stencil-to-lumina codemod
  *
- * @private
+ * @internal
  */
-export declare const exportsForCodemod: {
+export const exportsForCodemod: {
     initializeComponentDependencies: typeof initializeComponentDependencies;
     updateLuminaTs: typeof updateLuminaTs;
-    propertyToAttributeMappings: {
-        readonly common: Required<import('./jsxToLitHtml/config.ts').ElementPropertyToAttributeMappings>;
-        readonly perElement: Record<string, import('./jsxToLitHtml/config.ts').ElementPropertyToAttributeMappings | undefined>;
-    };
-    nativeEvents: Set<string>;
-    svgElements: Set<string>;
-    mathMlElements: Set<string>;
-    alwaysAttributes: Set<string>;
-    nativeAlwaysAttributes: Set<string>;
-    htmlAlwaysAttributes: Record<string, Set<string> | undefined>;
-};
+    propertyToAttributeMappings: typeof propertyToAttributeMappings;
+    nativeEvents: typeof nativeEvents;
+    svgElements: typeof svgElements;
+    mathMlElements: typeof mathMlElements;
+    alwaysAttributes: typeof alwaysAttributes;
+    nativeAlwaysAttributes: typeof nativeAlwaysAttributes;
+    htmlAlwaysAttributes: typeof htmlAlwaysAttributes;
+};

package/dist/index.js

@@ -2806,11 +2806,11 @@ const le = {
   apiJson: "docs/api.json",
   stencilLikeDocsJson: "docs/docs.json"
 }, Ze = (e) => e.viteConfig.root.includes("/test-packages/") ? 2 : void 0;
-async function Ki(e, t, i, s, r = O()) {
-  const n = Fn(e, r), a = m.join(t, "lumina.ts"), d = await _(a) ? await H(a, "utf8") : "";
-  if (d.trim().replaceAll(`\r
+async function Ki(e, t, i = O()) {
+  const s = Fn(e, i), r = m.join(t, "lumina.ts"), a = await _(r) ? await H(r, "utf8") : "";
+  if (a.trim().replaceAll(`\r
 `, `
-`) === n.trim())
+`) === s.trim())
     return !1;
   if (process.env.CI)
     throw Error(
@@ -2818,14 +2818,14 @@ async function Ki(e, t, i, s, r = O()) {
         "@arcgis/lumina:updateLuminaTs",
         `lumina.ts is out of date. Start the vite dev server or build locally at least once to update lumina.ts and commit the updated file. Tried to write the following content:
 
-${n}
+${s}
 
 Current content:
 
-${d}`
+${a}`
       )
     );
-  return ei(a, n), !0;
+  return ei(r, s), !0;
 }
 function Fn(e, t = O()) {
   const i = e.filter((d) => d.type === "@arcgis/lumina").map((d) => `
@@ -3204,6 +3204,10 @@ class $ {
    * A utility for making Vite copy assets to the output folder during build or
    * making Vite serve them when running in serve mode
    *
+   * @public
+   * @param assets
+   * @param transformers
+   * @param apply
    * @example
    * ```ts
    * // vite.config.ts
@@ -5279,7 +5283,7 @@ function Ia(e) {
   ).join(`
 `);
   return `
-/** @deprecated since 5.0. React wrappers are not needed in React 19 or above. Use <${e.tagName} /> directly. */
+/** @deprecated since 5.0. React wrappers are not needed in React 19 or above. Use \`<${e.tagName} />\` directly. */
 export const ${e.pascalCaseName} = /*@__PURE__*/ createWrapper(
   getReactWrapperOptions(
     "${e.tagName}" as unknown as HTML${e.pascalCaseName}Element,

package/dist/jsxToLitHtml/config.d.ts

@@ -1,42 +1,25 @@
-export declare const fragmentName = "Fragment";
-export declare const dynamicHtmlTagName = "DynamicHtmlTag";
-export declare const dynamicSvgTagName = "DynamicSvgTag";
-/**
- * Using symbols rather than strings for these so that the type system forces us
- * to handle the dynamic tag name case.
- */
-export declare const dynamicHtmlSymbol: unique symbol;
-export declare const dynamicSvgSymbol: unique symbol;
-/**
- * When Stencil encounters a JSX prop like "onArcgisClick", it converts the
- * first letter of the event name ("ArcgisClick") to lower case, and takes the
- * rest as is ("arcgisClick").
- *
- * But, Preact, React 19 and Lit (Lit JSX in turn) don't do any case
- * conversion so you have to use "onarcgisClick" instead.
- *
- * This means, if you are consuming web component authored in Stencil, it's
- * JSX typings may wrongly include properties like "onArcgisClick" rather
- * than "onarcgisClick".
- *
- * When consuming Stencil typings in a Lit project, we are creating a mapped
- * type that fixes the casing difference. But just in case any place slips
- * through, this flag is used to normalize the casing.
- */
-export declare const shouldNormalizeCustomElementEventCasing = true;
 /**
  * Always set these properties as attributes on all elements
+ *
+ * @internal
  */
-export declare const alwaysAttributes: Set<string>;
+export const alwaysAttributes: Set<string>;
+
 /**
  * Always set these properties as attributes on non-custom-elements
+ *
+ * @internal
  */
-export declare const nativeAlwaysAttributes: Set<string>;
+export const nativeAlwaysAttributes: Set<string>;
+
 /**
  * These don't exist as a property, only as an attribute.
  * Or, the property is read-only, but the attribute is not.
+ *
+ * @internal
  */
-export declare const htmlAlwaysAttributes: Record<string, Set<string> | undefined>;
+export const htmlAlwaysAttributes: Record<string, Set<string> | undefined>;
+
 /**
  * The mappings between native DOM property and the equivalent attribute it
  * reflects to.
@@ -44,81 +27,93 @@ export declare const htmlAlwaysAttributes: Record<string, Set<string> | undefine
  * This list was generated using the ./extractPropertyToAttributeMappings.js
  * script.
  *
+ * @internal
  */
-type PropertyToAttributeMappings = {
-    /**
-     * Mappings that are common to all HTML elements
-     */
-    readonly common: Required<ElementPropertyToAttributeMappings>;
-    /**
-     * Mappings that are specific to a given HTML element
-     */
-    readonly perElement: Record<string, ElementPropertyToAttributeMappings | undefined>;
-};
-export type ElementPropertyToAttributeMappings = {
-    /**
-     * This list is only used to apply an optional performance optimization.
-     * If it gets out of date or is missing some properties, it's not a big deal.
-     *
-     * This list is used to convert JSX properties with static values to
-     * an inlined HTML string that uses the equivalent attribute.
-     *
-     * Thus instead of `.property=${"1"}` final lit-html looks like `attribute=1`.
-     *
-     * Since static attributes are just part of the HTML string and not a special
-     * binding, lit-html doesn't have to waste time diffing them on re-render.
-     */
-    reflected?: Readonly<Record<string, string | undefined>>;
-    /**
-     * Unfortunately, for many DOM **properties**, when set to undefined
-     * (`el.autocapitalize = undefined`), rather than removing the attribute, they
-     * set the attribute to an `"undefined"` string (this is never a desirable
-     * outcome) or some other non-default value. This is the web platform
-     * behavior.
-     *
-     * lit-html also has an anti-feature of rendering `undefined` **attribute**
-     * values as `"undefined"` strings (they wanted to mirror the `.setAttribute()`
-     * behavior).
-     *
-     * Thus, the only way to unset such attributes in lit-html is to use attribute
-     * rather than property, and then add `?? nothing` to the attribute value.
-     * `nothing` is a special magic value Lit had to invent to mean
-     * "removeAttribute()"
-     *
-     * @see https://github.com/lit/lit/issues/4760
-     * @see https://x.com/maxpatiiuk/status/1840567140354798003
-     */
-    stringifiedReflected?: Readonly<Record<string, string | undefined>>;
-    /**
-     * Properties that when set to `undefined` value are actually set to
-     * `"undefined"` string.
-     *
-     * We cannot use `?? nothing` as `nothing` in property bindings acts the same
-     * as `undefined`.
-     *
-     * At the moment, all of these happen to be reset to default value when set
-     * to empty string, thus we add `?? ''` on these if potentially nullish value
-     * was provided.
-     */
-    stringifiedNonReflected?: Readonly<Record<string, "" | undefined>>;
-};
-export declare const propertyToAttributeMappings: PropertyToAttributeMappings;
-export declare const htmlAlwaysBooleanAttributes: Set<string>;
+export interface PropertyToAttributeMappings {
+  /**
+   * Mappings that are common to all HTML elements
+   *
+   * @internal
+   */
+  readonly common: Required<ElementPropertyToAttributeMappings>;
+  /**
+   * Mappings that are specific to a given HTML element
+   *
+   * @internal
+   */
+  readonly perElement: Record<string, ElementPropertyToAttributeMappings | undefined>;
+}
+
+/** @internal */
+export interface ElementPropertyToAttributeMappings {
+  /**
+   * This list is only used to apply an optional performance optimization.
+   * If it gets out of date or is missing some properties, it's not a big deal.
+   *
+   * This list is used to convert JSX properties with static values to
+   * an inlined HTML string that uses the equivalent attribute.
+   *
+   * Thus instead of `.property=${"1"}` final lit-html looks like `attribute=1`.
+   *
+   * Since static attributes are just part of the HTML string and not a special
+   * binding, lit-html doesn't have to waste time diffing them on re-render.
+   *
+   * @internal
+   */
+  reflected?: Readonly<Record<string, string | undefined>>;
+  /**
+   * Unfortunately, for many DOM **properties**, when set to undefined
+   * (`el.autocapitalize = undefined`), rather than removing the attribute, they
+   * set the attribute to an `"undefined"` string (this is never a desirable
+   * outcome) or some other non-default value. This is the web platform
+   * behavior.
+   *
+   * lit-html also has an anti-feature of rendering `undefined` **attribute**
+   * values as `"undefined"` strings (they wanted to mirror the `.setAttribute()`
+   * behavior).
+   *
+   * Thus, the only way to unset such attributes in lit-html is to use attribute
+   * rather than property, and then add `?? nothing` to the attribute value.
+   * `nothing` is a special magic value Lit had to invent to mean
+   * "removeAttribute()"
+   *
+   * @internal
+   * @see https://github.com/lit/lit/issues/4760
+   * @see https://x.com/maxpatiiuk/status/1840567140354798003
+   */
+  stringifiedReflected?: Readonly<Record<string, string | undefined>>;
+  /**
+   * Properties that when set to `undefined` value are actually set to
+   * `"undefined"` string.
+   *
+   * We cannot use `?? nothing` as `nothing` in property bindings acts the same
+   * as `undefined`.
+   *
+   * At the moment, all of these happen to be reset to default value when set
+   * to empty string, thus we add `?? ''` on these if potentially nullish value
+   * was provided.
+   *
+   * @internal
+   */
+  stringifiedNonReflected?: Readonly<Record<string, "" | undefined>>;
+}
+
+/** @internal */
+export const propertyToAttributeMappings: PropertyToAttributeMappings;
+
 /**
  * List of all DOM events settable in JSX. These event names are converted to
  * lowercase. All others are left as authored as we can't make assumptions about
  * what was the intended casing.
- */
-export declare const nativeEvents: Set<string>;
-/**
- * HTML elements that do not have children and closing tags
  *
- * Based on https://developer.mozilla.org/en-US/docs/Glossary/Void_element
+ * @internal
  */
-export declare const voidElements: Set<string>;
+export const nativeEvents: Set<string>;
+
 /**
  * Elements for which the `svg` function needs to be used rather than `html`.
  *
+ * @internal
  * @example
  * ```tsx
  * <svg>
@@ -133,26 +128,12 @@ export declare const voidElements: Set<string>;
  *
  * (foreign elements in HTML can be self-closing)
  */
-export declare const svgElements: Set<string>;
-/**
- * As per the spec, some HTML elements are valid inside of `<svg>`, without
- * being escaped in `<foreignObject>`.
- *
- * For such, it can be ambigous whether `html` or `svg` tag should be used.
- * If ambiguous element has non-ambiguous siblings,
- * jsxChildToTemplateParts will get the tag from them. Otherwise,
- * templatePartsToLitExpression will default to htmlTag, which will
- * probably work fine in all cases.
- *
- * @see https://svgwg.org/svg2-draft/struct.html#SVGElement
- * @see https://github.com/w3c/svgwg/blob/6d756e8e7159822e3e3b723756de6a025190bc68/master/definitions.xml#L281-L282
- * @see https://discord.com/channels/1012791295170859069/1286427223712071692
- *
- */
-export declare const ambiguousHtmlSvgElements: Set<string>;
+export const svgElements: Set<string>;
+
 /**
  * Elements for which the `math` function needs to be used rather than `html`
  *
+ * @internal
  * @example
  * ```tsx
  * <math>
@@ -167,13 +148,4 @@ export declare const ambiguousHtmlSvgElements: Set<string>;
  *
  * (foreign elements in HTML can be self-closing)
  */
-export declare const mathMlElements: Set<string>;
-/**
- * Although most native elements do not contain dashes inside, there are a
- * few exceptions. Explicitly declaring a custom element by this name is
- * forbidden
- *
- * @see https://developer.mozilla.org/en-US/docs/Web/API/CustomElementRegistry/define#valid_custom_element_names
- */
-export declare const blockListedCustomElementNames: Set<string>;
-export {};
+export const mathMlElements: Set<(string | string | string | string | string | string | string | string | string | string | string | string | string | string | string | string | string | string | string | string | string | string | string | string | string | string | string | string | string | string | string)>;