@arcgis/lumina-compiler 4.34.0-next.16 → 4.34.0-next.160

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/components-utils";
-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/testing/vitestTypes.d.ts

@@ -0,0 +1,8 @@
+export type VitestBrowserModeProvider = "playwright" | "preview" | "webdriverio" | (string & {}) | undefined;
+export type VitestPartialConfig = {
+    globalSetup?: string[] | string;
+    runner?: string;
+    include?: string[];
+    environment?: "edge-runtime" | "happy-dom" | "jsdom" | "node" | (Record<never, never> & string);
+    forceRerunTriggers?: string[];
+};

package/dist/transformers/injectRuntimeOptions.d.ts

@@ -1,3 +1,13 @@
-import { SourceDescription } from 'rollup';
 import { CompilerContext } from '../context';
-export declare function injectRuntimeOptions(runtimeTsCode: string, context: CompilerContext): SourceDescription;
+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.
+ * We also inject CSS imports for Lumina dependencies this package uses - this
+ * is needed to ensure CSS is loaded in correct order - this does not cause
+ * duplicate CSS bundling.
+ *
+ * Research notes: https://devtopia.esri.com/WebGIS/arcgis-web-components/discussions/1824#discussioncomment-12625
+ */
+export declare function getGlobalCssImport(context: CompilerContext): string;

package/dist/transformers/internalTypeScriptApis.d.ts

@@ -1,5 +1,8 @@
-import { SourceMap } from 'rollup';
 import { default as ts } from 'typescript';
+import { TransformResult } from 'vite';
+type SourceMap = Extract<NonNullable<TransformResult["map"]>, {
+    file: string;
+}>;
 export type UndocumentedTypeScript = {
     readonly createSourceMapGenerator?: (host: ts.CompilerHost, basename: string, sourceRoot: string, dirname: string, compilerOptions: ts.CompilerOptions) => SourceMapGenerator;
     readonly createTextWriter?: (newLine: string) => EmitTextWriter;

package/dist/transformers/utils.d.ts

@@ -1,14 +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;
-/**
- * For performance reasons, to avoid the need to re-create the source map
- * after this change, replace the given code string with a comment string of
- * equal length :)
- */
-export declare const commentOutCode: (match: string) => string;
+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.16",
+  "version": "4.34.0-next.160",
   "type": "module",
   "main": "dist/index.js",
   "module": "dist/index.js",
@@ -18,25 +18,27 @@
   ],
   "license": "SEE LICENSE IN LICENSE.md",
   "dependencies": {
-    "@arcgis/api-extractor": "4.34.0-next.16",
-    "@arcgis/components-build-utils": "4.34.0-next.16",
-    "@arcgis/components-utils": "4.34.0-next.16",
-    "chalk": "^5.3.0",
-    "esbuild": "^0.25.4",
-    "glob": "^11.0.0",
-    "js-beautify": "^1.15.1",
-    "mime-types": "^2.1.35",
-    "rollup": "^4.40.2",
-    "rollup-plugin-node-externals": "^8.0.0",
-    "sass-embedded": "^1.79.3",
+    "@arcgis/api-extractor": "4.34.0-next.160",
+    "@arcgis/components-build-utils": "4.34.0-next.160",
+    "@arcgis/toolkit": "~4.34.0-next.160",
+    "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",
-    "typescript": "~5.8.3",
-    "vite": "^6.3.4",
-    "vite-plugin-dts": "^4.5.3",
-    "vitest": "^3.1.3",
-    "vitest-fail-on-console": "^0.7.1"
+    "vite-plugin-dts": "^4.5.4"
   },
   "peerDependencies": {
-    "@arcgis/lumina": "~4.34.0-next.16"
+    "@arcgis/lumina": "~4.34.0-next.160",
+    "lit": "^3.3.0",
+    "typescript": "~5.8.3",
+    "vite": "^7.0.0",
+    "vitest": "^3.2.4"
+  },
+  "peerDependenciesMeta": {
+    "vitest": {
+      "optional": true
+    }
   }
 }

package/dist/jsxToLitHtml/escapeForTemplateLiteral.d.ts

@@ -1,45 +0,0 @@
-/**
- * This file is a workaround for a TypeScript bug:
- * https://github.com/microsoft/TypeScript/issues/59150
- *
- * Once that bug is fixed, the code can be simplified like so:
- * - This file can be removed
- * - For each place where `escapeBackticks` or `escapeForTemplateLiteral` was
- *   used and the result was passed as the 1st AND 2nd parameter to one of
- *   ts.factory.createNoSubstitutionTemplateLiteral,
- *   ts.factory.createTemplateHead, ts.factory.createTemplateMiddle, or
- *   ts.factory.createTemplateTail, change those places like so:
- *   - DO NOT call `escapeBackticks` or `escapeForTemplateLiteral` anymore -
- *     pass the value as is.
- *   - DO NOT provide the 2nd parameter to the factory function.
- * - If `escapeForTemplateLiteral` was used in some other place, it can
- *   potentially be replaced with a function like this:
- *   string=>escapeTemplateSubstitution(string).replaceAll('`','\`')
- *   (where escapeTemplateSubstitution is defined in the current file - move it)
- *
- * More details:
- *
- * In template literals, even though we *really* only need to escape ${ and
- * backticks, we are escaping non-ASCII characters too as that improves scanner
- * performance in JavaScript engines.
- *
- * This is what esbuild does (https://esbuild.github.io/api/#charset), what
- * V8 recommends (https://v8.dev/blog/scanner) and what TypeScript does.
- *
- * The code in this file has been copied from TypeScript's code for escaping
- * template literals (but simplified to remove dead branches and fix eslint
- * warnings):
- * https://github.com/microsoft/TypeScript/blob/3163fe7e3898c1f48cd9bc097b96e3426cd2a453/src/compiler/utilities.ts#L5918-L5986
- *
- * TypeScript can automatically escape template literals for us, but we opt out
- * of that as, due to a bug, they also escape new line characters which is not
- * good as it decreases readability when debugging code.
- *
- * TypeScript does not expose the template literal escaping utils so we had
- * to copy the code here, but modify to not escape new lines.
- *
- */
-declare function escapeNonAsciiString(s: string): string;
-export declare const escapeBackticks: typeof escapeNonAsciiString;
-export declare const escapeTemplateSubstitution: (str: string) => string;
-export {};

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

package/dist/plugins/buildStencilHydrate.d.ts

@@ -1,16 +0,0 @@
-import { Plugin } from 'vite';
-import { CompilerContext } from '../context';
-/**
- * Emit output compatible with Stencil's dist-hydrate-script build.
- *
- * Based on https://github.com/ionic-team/stencil/blob/main/src/compiler/output-targets/dist-hydrate-script/write-hydrate-outputs.ts
- *
- * @deprecated
- * This option should be used to smooth the migration path from Stencil.
- * You should instruct your SSR users to migrate to Lit's SSR implementation,
- * and then stop using this option.
- *
- * @see https://stenciljs.com/docs/hydrate-app
- * @see https://lit.dev/docs/ssr/overview/
- */
-export declare function buildStencilHydrate(context: CompilerContext): Plugin | undefined;