@arcgis/lumina-compiler 4.34.0-next.99 → 5.0.0-next.0

package/dist/jsxToLitHtml/types.d.ts

@@ -68,5 +68,7 @@ export type LitTag = (typeof litTagsArray)[number];
 export declare const jsxImportNames: readonly ["keyed", "ref", "repeat", "live", "css", "html", "mathml", "staticHtml", "staticSvg", "svg", "safeClassMap", "safeStyleMap", "deferLoad", "stabilizedRef", "nothing"];
 export type JsxImportName = (typeof jsxImportNames)[number];
 export type JsxHost = ts.JsxElement | ts.JsxFragment | ts.JsxSelfClosingElement;
+/** Returns `true` if the given node is an array expression containing jsx nodes */
+export declare const isJsxArray: (node: ts.Node) => node is ts.ArrayLiteralExpression;
 export declare const isJsxHost: (node: ts.Node) => node is JsxHost;
 export {};

package/dist/loader/index.d.ts

@@ -10,4 +10,4 @@ import { CompilerContext } from '../context';
  * The generated api.json is then used by componentTransformPipeline() and by
  * generateDocs(), among others.
  */
-export declare function generateVirtualFiles(context: CompilerContext): VitePlugin;
+export declare function generateVirtualFiles(context: CompilerContext): readonly [VitePlugin, VitePlugin];

package/dist/loader/lazy.d.ts

@@ -15,7 +15,7 @@ export declare const loaderDts = "import \"./index\";\nexport declare const defi
  * properties, attributes, asynchronous methods and synchronous methods.
  */
 declare function buildCompactLazyMeta(customElement: Pick<ApiCustomElementDeclaration, "members" | "tagName">): string;
-export declare function buildLazyBeta(customElement: Pick<ApiCustomElementDeclaration, "members" | "tagName">): HmrComponentMeta;
+export declare function buildLazyMeta(customElement: Pick<ApiCustomElementDeclaration, "members" | "tagName">): HmrComponentMeta;
 export declare const exportsForTests: {
     buildCompactLazyMeta: typeof buildCompactLazyMeta;
 };

package/dist/logger-hJvg0JOj.js

@@ -0,0 +1,34 @@
+import { setApiExtractorErrorLogger as c } from "@arcgis/api-extractor";
+import { toSystemPathSeparators as i, path as g } from "@arcgis/components-build-utils";
+import a from "chalk";
+let e = {
+  // Temporary logger to use until vite config is loaded and we have access to
+  // actual logger.
+  info: console.log,
+  warn: console.warn,
+  error: console.error
+}, s = process.cwd();
+function n(t, r, o) {
+  return typeof o == "string" ? (o = o.startsWith(s) ? i(g.relative(s, o)) : o, o = `${o}: `) : o = "", `${t} ${o}${r}`;
+}
+const f = {
+  initialize(t, r) {
+    e = t, s = r, c(e.error);
+  },
+  info(t, r, o) {
+    e.info(n(a.cyan(`[${t}]`), r, o));
+  },
+  warn(t, r, o) {
+    e.warn(n(a.yellow(`[${t}]`), r, o));
+  },
+  error(t, r, o) {
+    e.error(n(a.red(`[${t}]`), r, o)), process.exitCode = 1;
+  }
+};
+function l(t, r, o) {
+  return r instanceof Error ? (r.message = n(t, r.message, o), r) : n(a.red(`[${t}]`), r, o);
+}
+export {
+  l as f,
+  f as l
+};

package/dist/plugins/buildCdn.d.ts

@@ -65,7 +65,13 @@ export declare function buildLoaderCode(runtimeVariableName: string, customEntry
  * ```
  */
 declare function transformChunk(chunk: CdnChunk, chunks: Map<string, CdnChunk>): void;
+/**
+ * Given set of identifiers, produce the shortest possible ASCII-only identifier.
+ * We restrict to ASCII-range as it is faster to parse for engines.
+ */
+declare function createIdentifierGenerator(seen: Set<string>): () => string;
 export declare const exportsForTests: {
     transformChunk: typeof transformChunk;
+    createIdentifierGenerator: typeof createIdentifierGenerator;
 };
 export {};

package/dist/plugins/loadLitCss.d.ts

@@ -96,7 +96,7 @@ export declare const globalCssFileFlag = "?globalFileLitCss";
  *
  * Then, we augment it into this:
  * ```js
- * import { css } from '@lit/reactive-element/css-tag.js';
+ * import { css } from 'lit/css-tag.js';
  * const styles = css`:host{display:flex;gap:1rem}button{padding:1rem}`;
  * export default styles;
  * ```

package/dist/publicTypes.d.ts

@@ -37,10 +37,9 @@ export type LuminaOptions = {
      * For more options, see Vite's "testing" option.
      * This is equivalent to the `e2e` mode in Stencil.
      *
-     * @remarks
-     * For new projects, we recommend using Vitest browser mode instead of
-     * Puppeteer. See documentation:
-     * https://qawebgis.esri.com/components/lumina/testing
+     * @deprecated
+     * For new projects, use Vitest browser mode instead of Puppeteer.
+     * See documentation: https://qawebgis.esri.com/components/lumina/testing
      */
     readonly puppeteerTesting?: PuppeteerTestingOptions;
     /**
@@ -100,7 +99,7 @@ export type BuildOptions = {
      * New lines are accepted.
      * Do not include // or /* - will be added automatically.
      *
-     * @default require("@arcgis/components-utils").getPreamble()
+     * @default require("@arcgis/toolkit/string").getPreamble()
      *
      * @example
      * ```js
@@ -156,7 +155,15 @@ export type BuildCdnOptions = {
      */
     readonly esbuildOptions?: Parameters<typeof esbuildBuild>[0];
     /**
-     * A callback for mutating CDN chunks before they are written to disk.
+     * Transform the CDN entrypoint before it is processed by ESBuild.
+     *
+     * This callback is for advanced use cases only. The build output may change
+     * between Lumina versions without prior notice.
+     */
+    readonly entrypointTransformer?: (code: string, context: CompilerContext) => string;
+    /**
+     * A callback for mutating CDN ESBuild output chunks before they are written
+     * to disk.
      * This callback is for advanced use cases only. The build output may change
      * between Lumina versions without prior notice. Using this callback may
      * corrupt the CDN source map if it is enabled.
@@ -165,6 +172,11 @@ export type BuildCdnOptions = {
 };
 export type CdnChunk = {
     code: string;
+    /**
+     * Whether chunk is currently being processed. Used to detect cyclical imports.
+     * @private
+     */
+    isProcessing: boolean;
     isAsync: boolean | undefined;
     oldSingleExportName: string | undefined;
 };
@@ -247,9 +259,17 @@ export type DetailedExtraDependency = {
      */
     getCdnUrl: (context: CompilerContext) => string;
 };
+/**
+ * @deprecated
+ * For new projects, use Vitest browser mode instead of Puppeteer.
+ * See documentation: https://qawebgis.esri.com/components/lumina/testing
+ */
 export type PuppeteerTestingOptions = {
     /**
      * @default false
+     * @deprecated
+     * For new projects, use Vitest browser mode instead of Puppeteer.
+     * See documentation: https://qawebgis.esri.com/components/lumina/testing
      */
     readonly enabled?: boolean;
     /**

package/dist/puppeteerTesting/globalSetup.d.ts

@@ -26,7 +26,7 @@ declare module "vitest" {
  *
  * It has to be separate because Vitest's dev server resolves imports for the
  * "node" import condition. If we instead tell Vitest to use browser export
- * conditions, than Lit's "isServer" will be false both in browser and node.js,
+ * conditions, then Lit's "isServer" will be false both in browser and node.js,
  * potentially breaking some components. While happy-dom is neat, it does match
  * the actual browser API 100%. It is safer to run a separate Vite instance for
  * Node.js (Vitest) and browser. This is a short-term issue anyway as we are

package/dist/puppeteerTesting/index.js

@@ -1,7 +1,7 @@
 import { expect as p, afterEach as V } from "vitest";
 import { toSystemPathSeparators as L, isPosix as S } from "@arcgis/components-build-utils";
 import { p as T, i as h } from "../types-C3YmWTVv.js";
-import { l as y } from "../logger-KpGU2b3R.js";
+import { l as y } from "../logger-hJvg0JOj.js";
 async function D(s) {
   await s.exposeFunction("puppeteerOnEvent", (e, t) => {
     j(s._e2eEvents, e, t);

package/dist/testing/failOnConsole.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Based on https://github.com/thomasbrodusch/vitest-fail-on-console/, but
+ * simplified and with our fixes applied:
+ * https://github.com/thomasbrodusch/vitest-fail-on-console/issues/61
+ */
+export declare function failOnConsole(): void;

package/dist/testing/index.js

@@ -1,39 +1,39 @@
-import { render as C } from "lit-html";
-import { unsafeStatic as m, html as w } from "lit-html/static.js";
-import { devOnly$getLitElementTagNameAndRuntime as $, LitElement as S } from "@arcgis/lumina";
-import { camelToKebab as _ } from "@arcgis/toolkit/string";
-import { onTestFinished as x, expect as E } from "vitest";
-import O from "vitest-fail-on-console";
-import R from "js-beautify";
-import { toFunction as D } from "@arcgis/lumina/controllers";
-async function G(e, { parent: t = document.body, afterConnect: o, dynamicComponents: f, cleanupAfterTest: s = !0 } = {}) {
+import { render as C } from "lit";
+import { unsafeStatic as m, html as w } from "lit/static-html.js";
+import { devOnly$getLitElementTagNameAndRuntime as x, LitElement as O } from "@arcgis/lumina";
+import { camelToKebab as S } from "@arcgis/toolkit/string";
+import { onTestFinished as _, beforeEach as R, afterEach as D, expect as M } from "vitest";
+import b from "chalk";
+import j from "js-beautify";
+import { toFunction as z } from "@arcgis/lumina/controllers";
+async function X(e, { parent: t = document.body, afterConnect: o, dynamicComponents: f, cleanupAfterTest: r = !0 } = {}) {
   const n = document.createElement("div");
-  n.style.display = "contents", t.append(n), s && x(() => j(n)), v(e);
+  n.style.display = "contents", t.append(n), r && _(() => F(n)), v(e);
   const l = f?.some(v);
-  let r;
+  let i;
   if (typeof e == "string")
-    r = w`<${m(e)}></${m(e)}>`;
+    i = w`<${m(e)}></${m(e)}>`;
   else if (typeof e == "function")
     if (p(e)) {
-      const c = $(e).tagName;
-      r = w`<${m(c)}></${m(c)}>`;
+      const a = x(e).tagName;
+      i = w`<${m(a)}></${m(a)}>`;
     } else
-      r = e();
+      i = e();
   else {
     if (l)
       throw new Error(
         'When rendering a dynamically created custom element using Lit\'s html`` function, you must ensure that the custom element class name is unique in the test file, or the class should explicitly have the `static tagName = "some-tag-name";` property with a unique tag name within the test file'
       );
-    r = e;
+    i = e;
   }
-  const i = [];
-  function a(c) {
-    i.push(c.error), c.preventDefault(), c.stopPropagation();
+  const s = [];
+  function c(a) {
+    s.push(a.error), a.preventDefault(), a.stopPropagation();
   }
-  if (window.addEventListener("error", a), C(r, n), window.removeEventListener("error", a), i.length === 1)
-    throw i[0];
-  if (i.length > 1)
-    throw new AggregateError(i, "Multiple errors occurred while creating the custom element");
+  if (window.addEventListener("error", c), C(i, n), window.removeEventListener("error", c), s.length === 1)
+    throw s[0];
+  if (s.length > 1)
+    throw new AggregateError(s, "Multiple errors occurred while creating the custom element");
   const u = L(n), N = g, y = o?.(u);
   y?.then !== void 0 && await y;
   const d = u;
@@ -49,11 +49,11 @@ async function G(e, { parent: t = document.body, afterConnect: o, dynamicCompone
   };
 }
 let g;
-const M = globalThis;
-M.devOnly$luminaComponentRefCallback = (e) => {
+const A = globalThis;
+A.devOnly$luminaComponentRefCallback = (e) => {
   g = e;
 };
-function j(e) {
+function F(e) {
   for (; e.firstChild; )
     e.removeChild(e.firstChild);
   e instanceof HTMLElement && e.remove();
@@ -61,25 +61,25 @@ function j(e) {
 function v(e) {
   if (!p(e))
     return !1;
-  const { runtime: t, tagName: o = e.tagName } = $(e);
+  const { runtime: t, tagName: o = e.tagName } = x(e);
   if (t !== void 0)
     return !1;
-  let s = !1, n = o;
+  let r = !1, n = o;
   if (n === void 0) {
-    const l = _(
+    const l = S(
       /*
        * If name is a single letter, it was probably minified - thus is not
        * stable, thus don't use it. Example: class produced by wrapController()
        */
-      (e.name.length > 1 ? e.name.replaceAll(z, "") : "") || "Test"
-    ), r = l === "test" ? "te-st" : l.includes("-") ? l : `${l}-`;
-    n = r;
-    for (let i = 2, a = customElements.get(n); a !== e && a !== void 0; i += 1)
-      s = !0, n = `${r}-${i}`, a = customElements.get(n);
+      (e.name.length > 1 ? e.name.replaceAll(q, "") : "") || "Test"
+    ), i = l === "test" ? "te-st" : l.includes("-") ? l : `${l}-`;
+    n = i;
+    for (let s = 2, c = customElements.get(n); c !== e && c !== void 0; s += 1)
+      r = !0, n = `${i}-${s}`, c = customElements.get(n);
   }
-  return globalThis.devOnly$luminaRuntime?.customElement(n, e), Object.defineProperty(e.prototype, "tagName", { value: n.toUpperCase() }), s;
+  return globalThis.devOnly$luminaRuntime?.customElement(n, e), Object.defineProperty(e.prototype, "tagName", { value: n.toUpperCase() }), r;
 }
-const p = (e) => typeof e == "function" && "lumina" in e, z = /\d+$/gu;
+const p = (e) => typeof e == "function" && "lumina" in e, q = /\d+$/gu;
 function L(e) {
   for (const t of e.children)
     if ("lumina" in t.constructor)
@@ -91,15 +91,43 @@ function L(e) {
   }
   return e.firstElementChild ?? g?.el;
 }
-function A() {
-  E.addSnapshotSerializer({
+function H() {
+  const e = $("warn"), t = $("error");
+  R(() => {
+    e.beforeEach(), t.beforeEach();
+  }), D(() => {
+    e.afterEach(), t.afterEach();
+  });
+}
+function $(e) {
+  let t = !1;
+  const o = console[e];
+  function f(...r) {
+    o(...r), t = !0;
+  }
+  return {
+    beforeEach() {
+      console[e] = f;
+    },
+    afterEach() {
+      if (t)
+        throw new Error(`[@arcgis/lumina:failOnConsole] Expected test not to call ${b.bold(`console.${e}()`)}.
+    If the ${e} is expected, test for it explicitly by mocking it out using:
+    ${b.bold(`vi.spyOn(console, '${e}').mockImplementation(() => {}) `)}
+    and test that the ${e} occurs.`);
+      console[e] = o;
+    }
+  };
+}
+function P() {
+  M.addSnapshotSerializer({
     // Using duck typing to detect ShadowRoot. Not using instanceof to keep test fast
     test(e) {
       return typeof e == "object" && e !== null && "innerHTML" in e && "onslotchange" in e;
     },
     serialize(e) {
-      const t = e.innerHTML.replaceAll(F, "");
-      return R.html(t, {
+      const t = e.innerHTML.replaceAll(U, "");
+      return j.html(t, {
         /* eslint-disable @typescript-eslint/naming-convention */
         indent_size: 2,
         indent_char: " ",
@@ -112,26 +140,17 @@ function A() {
     }
   });
 }
-const F = /<!--\??(?:lit\$\d+\$)?-->/gu;
-function I() {
-  if (b[T])
-    return;
-  b[T] = !0;
-  const e = { ...console };
-  O({
-    // Workaround for https://github.com/thomasbrodusch/vitest-fail-on-console/issues/61
-    silenceMessage(t, o) {
-      return e[o](t), !1;
-    }
-  }), A();
+const U = /<!--\??(?:lit\$\d+\$)?-->/gu;
+function Y() {
+  T[E] || (T[E] = !0, H(), P());
 }
-const T = Symbol.for("lumina:didSetupTest"), b = globalThis;
-function J(e, t) {
-  class o extends S {
+const E = Symbol.for("lumina:didSetupTest"), T = globalThis;
+function Z(e, t) {
+  class o extends O {
     constructor() {
       super();
-      const s = "prototype" in e ? D(e) : e;
-      this.controller = s(this), Promise.resolve(t?.(this)).catch(console.error);
+      const r = "prototype" in e ? z(e) : e;
+      this.controller = r(this), Promise.resolve(t?.(this)).catch(console.error);
     }
     /*
      * Emitting controller's exports here is useful to let controller tests
@@ -146,7 +165,7 @@ function J(e, t) {
   return o;
 }
 export {
-  G as mount,
-  I as setupLuminaTest,
-  J as wrapController
+  X as mount,
+  Y as setupLuminaTest,
+  Z as wrapController
 };

package/dist/testing/mount.d.ts

@@ -1,4 +1,4 @@
-import { TemplateResult } from 'lit-html';
+import { TemplateResult } from 'lit';
 import { JsxNode, LitElement, ToElement } from '@arcgis/lumina';
 export type RenderResult<Component extends HTMLElement> = {
     /**
@@ -98,7 +98,7 @@ export type RenderOptions<Component extends HTMLElement = HTMLElement> = {
  * In it's simplest form, what this function is doing is the following:
  *
  * ```tsx
- * import { render } from "lit-html";
+ * import { render } from "lit";
  * render(<arcgis-counter />, document.body);
  * const el = document.querySelector("arcgis-counter")!;
  * await el.componentOnReady();

package/dist/transformers/injectRuntimeOptions.d.ts

@@ -1,6 +1,6 @@
 import { CompilerContext } from '../context';
-import { TransformResult } from 'vite';
-export declare function injectRuntimeOptions(runtimeTsCode: string, context: CompilerContext): TransformResult;
+import { Plugin } from 'vite';
+export declare const injectRuntimeOptions: (context: CompilerContext) => Plugin;
 /**
  * Add to chunks/runtime.js import statement for the global CSS file.
  * This way CSS is injected automatically, simplifying get started instructions.

package/dist/transformers/utils.d.ts

@@ -1,8 +1,9 @@
 import { default as ts } from 'typescript';
-import { FileTransformer } from '../publicTypes';
+import { FileTransformContext, FileTransformer } from '../publicTypes';
 import { CompilerContext } from '../context';
 /**
  * Run a chain of transformers on a TypeScript .tsx or .d.ts file and return
  * the resulting source file
  */
 export declare function runTransformers(context: CompilerContext, transformationContext: ts.TransformationContext, sourceFile: ts.SourceFile, transformers: readonly FileTransformer[]): ts.SourceFile;
+export declare function removeComments(node: ts.Node, context: FileTransformContext): void;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arcgis/lumina-compiler",
-  "version": "4.34.0-next.99",
+  "version": "5.0.0-next.0",
   "type": "module",
   "main": "dist/index.js",
   "module": "dist/index.js",
@@ -18,20 +18,19 @@
   ],
   "license": "SEE LICENSE IN LICENSE.md",
   "dependencies": {
-    "@arcgis/api-extractor": "4.34.0-next.99",
-    "@arcgis/components-build-utils": "4.34.0-next.99",
-    "@arcgis/toolkit": "4.34.0-next.99",
+    "@arcgis/api-extractor": "5.0.0-next.0",
+    "@arcgis/components-build-utils": "5.0.0-next.0",
+    "@arcgis/toolkit": "~5.0.0-next.0",
     "chalk": "^5.4.1",
     "esbuild": "^0.25.5",
     "glob": "^11.0.3",
     "js-beautify": "^1.15.4",
     "mime-types": "^3.0.1",
     "tslib": "^2.8.1",
-    "vite-plugin-dts": "^4.5.4",
-    "vitest-fail-on-console": "^0.7.1"
+    "vite-plugin-dts": "^4.5.4"
   },
   "peerDependencies": {
-    "@arcgis/lumina": "~4.34.0-next.99",
+    "@arcgis/lumina": "~5.0.0-next.0",
     "lit": "^3.3.0",
     "typescript": "~5.8.3",
     "vite": "^7.0.0",

package/dist/logger-KpGU2b3R.js

@@ -1,28 +0,0 @@
-import { toSystemPathSeparators as i, path as c } from "@arcgis/components-build-utils";
-import a from "chalk";
-import { createLogger as g } from "vite";
-let n = g(), s = process.cwd();
-function e(r, o, t) {
-  return typeof t == "string" ? (t = t.startsWith(s) ? i(c.relative(s, t)) : t, t = `${t}: `) : t = "", `${r} ${t}${o}`;
-}
-const f = {
-  initialize(r, o) {
-    n = r, s = o;
-  },
-  info(r, o, t) {
-    n.info(e(a.cyan(`[${r}]`), o, t));
-  },
-  warn(r, o, t) {
-    n.warn(e(a.yellow(`[${r}]`), o, t));
-  },
-  error(r, o, t) {
-    n.error(e(a.red(`[${r}]`), o, t)), process.exitCode = 1;
-  }
-};
-function u(r, o, t) {
-  return o instanceof Error ? (o.message = e(r, o.message, t), o) : e(a.red(`[${r}]`), o, t);
-}
-export {
-  u as f,
-  f as l
-};