@arcgis/components-build-utils 4.33.0-next.13 → 4.33.0-next.133

package/dist/index.js

@@ -1,11 +1,17 @@
-// src/file.ts
-import { existsSync } from "node:fs";
-import { access, constants, mkdir, writeFile } from "node:fs/promises";
+import { access, existsSync, readFileSync } from "node:fs";
+import { constants, mkdir, writeFile, readFile } from "node:fs/promises";
 import { execSync } from "node:child_process";
-import { dirname, join, resolve, sep } from "path";
+import { dirname, resolve, sep, join } from "node:path";
 import { fileURLToPath } from "node:url";
-var existsAsync = async (file) => await access(file, constants.F_OK).then(() => true).catch(() => false);
-var sh = (command, cwd) => execSync(command.trim(), { encoding: "utf8", cwd }).trim();
+import posix from "node:path/posix";
+import win32 from "node:path/win32";
+import dts from "vite-plugin-dts";
+const existsAsync = async (file) => (
+  // Using un-promisified version because promises version creates exceptions
+  // which interferes with debugging when "Pause on caught exceptions" is enabled
+  await new Promise((resolve2) => access(file, constants.F_OK, (error) => resolve2(!error)))
+);
+const sh = (command, cwd) => execSync(command.trim(), { encoding: "utf8", cwd }).trim();
 async function createFileIfNotExists(filePath, content) {
   await mkdir(dirname(filePath), { recursive: true });
   if (!await existsAsync(filePath)) {
@@ -44,9 +50,7 @@ async function asyncFindPath(target, startDirectory = process.cwd()) {
   }
   return void 0;
 }
-
-// src/glob.ts
-var gitIgnoreToGlob = (pattern) => fixAbsoluteSyntax(fixMatchFilesSyntax(pattern));
+const gitIgnoreToGlob = (pattern) => fixAbsoluteSyntax(fixMatchFilesSyntax(pattern));
 function fixAbsoluteSyntax(pattern) {
   if (pattern.startsWith("/")) {
     return pattern.slice(1);
@@ -66,18 +70,13 @@ function fixMatchFilesSyntax(pattern) {
   }
   return pattern.endsWith("/*") ? `${pattern}*` : pattern.endsWith("/") ? `${pattern}**` : `${pattern}/**`;
 }
-
-// src/path.ts
-import { sep as sep2 } from "path";
-import posix from "path/posix";
-import win32 from "path/win32";
-var isPosix = sep2 === posix.sep;
-var toPosixPathSeparators = (relativePath) => relativePath.includes(win32.sep) ? relativePath.replaceAll(win32.sep, posix.sep) : relativePath;
-var normalizePath = isPosix ? (path2) => path2 : toPosixPathSeparators;
-var toWin32PathSeparators = (relativePath) => relativePath.includes(posix.sep) ? relativePath.replaceAll(posix.sep, win32.sep) : relativePath;
-var toSystemPathSeparators = isPosix ? (path2) => path2 : toWin32PathSeparators;
-var getCwd = isPosix ? process.cwd : () => toPosixPathSeparators(process.cwd());
-var path = isPosix ? posix : {
+const isPosix = sep === posix.sep;
+const toPosixPathSeparators = (relativePath) => relativePath.includes(win32.sep) ? relativePath.replaceAll(win32.sep, posix.sep) : relativePath;
+const normalizePath = isPosix ? (path2) => path2 : toPosixPathSeparators;
+const toWin32PathSeparators = (relativePath) => relativePath.includes(posix.sep) ? relativePath.replaceAll(posix.sep, win32.sep) : relativePath;
+const toSystemPathSeparators = isPosix ? (path2) => path2 : toWin32PathSeparators;
+const getCwd = isPosix ? process.cwd : () => toPosixPathSeparators(process.cwd());
+const path = isPosix ? posix : {
   ...win32,
   sep: posix.sep,
   join(...paths) {
@@ -105,14 +104,10 @@ var path = isPosix ? posix : {
     return toPosixPathSeparators(result);
   }
 };
-var exportsForTests = { toWin32PathSeparators };
-
-// src/packageJson.ts
-import { readFile } from "node:fs/promises";
-import { existsSync as existsSync2, readFileSync } from "node:fs";
-var cachedPackageJson = {};
-var cachedPackageJsonPromises = {};
-var rootPackageJsonLocation;
+const exportsForTests = { toWin32PathSeparators };
+const cachedPackageJson = {};
+const cachedPackageJsonPromises = {};
+let rootPackageJsonLocation;
 function retrievePackageJson(location) {
   const packageJsonPath = location ? path.resolve(location, "package.json") : rootPackageJsonLocation ??= findPath("package.json");
   cachedPackageJson[packageJsonPath] ??= JSON.parse(readFileSync(packageJsonPath, "utf-8"));
@@ -128,9 +123,9 @@ async function asyncRetrievePackageJson(location = getCwd()) {
   cachedPackageJson[packageJsonPath] ??= result;
   return result;
 }
-var asyncReadPackageJson = async (location) => JSON.parse(await readFile(location, "utf-8"));
-var cachedPackageLocation = {};
-var cachedPackageLocationPromises = {};
+const asyncReadPackageJson = async (location) => JSON.parse(await readFile(location, "utf-8"));
+const cachedPackageLocation = {};
+const cachedPackageLocationPromises = {};
 async function fetchPackageLocation(packageName, cwd) {
   if (packageName in cachedPackageLocation) {
     return cachedPackageLocation[packageName];
@@ -140,8 +135,8 @@ async function fetchPackageLocation(packageName, cwd) {
     cwd
   ).then((packageJsonLocation) => {
     if (packageJsonLocation === void 0) {
-      throw new Error(
-        `@arcgis/lumina-compiler: Unable to resolve package.json location for "${packageName}" package. Current working directory: ${process.cwd()}`
+      throw Error(
+        `@arcgis/components-build-utils: Unable to resolve package.json location for "${packageName}" package. Current working directory: ${process.cwd()}`
       );
     }
     return path.dirname(packageJsonLocation);
@@ -157,7 +152,7 @@ function detectPackageManager(cwd = process.cwd()) {
     while (pathParts.length > 1) {
       const packageJson = path.join(pathParts.join(path.sep), "package.json");
       pathParts.pop();
-      if (!existsSync2(packageJson)) {
+      if (!existsSync(packageJson)) {
         continue;
       }
       const contents = JSON.parse(readFileSync(packageJson, "utf8"));
@@ -172,6 +167,106 @@ function detectPackageManager(cwd = process.cwd()) {
   packageManager ??= "npm";
   return packageManager;
 }
+function vitePresetPlugin({
+  externalize = [],
+  dtsOptions = {}
+} = {
+  externalize: [],
+  dtsOptions: {}
+}) {
+  const dist = `${path.resolve("dist")}/`;
+  const distSrc = `${dist}src/`;
+  let userConfig = void 0;
+  let command = void 0;
+  return [
+    {
+      name: "vite-preset-config",
+      config({ build: { target } = {} }, env) {
+        command = env.command;
+        return {
+          build: {
+            // REFACTOR: get this from tsconfig
+            // It's a best practice to let the final bundler down-level as needed.
+            target: target ?? "es2022"
+          },
+          define: env.mode === "test" ? {
+            "process.env.ESRI_INTERNAL": true
+          } : void 0
+        };
+      },
+      configResolved(config) {
+        userConfig = config;
+      }
+    },
+    /**
+     * We use a dynamic import here because of how Rollup processes and transforms imports.
+     * This dependency (rollup-plugin-node-externals) will not be bundled into the output,
+     * as specified in vite.config.ts.
+     *
+     * rollup-plugin-node-externals is an ES module, and Stencil throws an error when it encounters
+     * a require() statement for an ES module.
+     *
+     * If we used a static import, Rollup's cjs build would transform it into a require() statement,
+     * causing Stencil to throw an error. Using a dynamic import prevents this issue.
+     */
+    import("rollup-plugin-node-externals").then(
+      ({ nodeExternals }) => nodeExternals({
+        include: externalize.map(stringToStartsWithGlob)
+      })
+    ),
+    dts({
+      logLevel: "warn",
+      // Copies .d.ts files to d.cjs file for CommonJS.
+      // Adds a performance hit as it occurs after the build
+      async afterBuild(emitted) {
+        if (userConfig?.build?.lib && userConfig.build.lib.formats?.includes("cjs")) {
+          await Promise.all(
+            emitted.entries().map(async ([filePath, content]) => {
+              if (filePath.endsWith(".d.ts")) {
+                await writeFile(filePath.replace(".d.ts", ".d.cts"), content);
+              }
+            })
+          );
+        }
+      },
+      ...dtsOptions,
+      compilerOptions: {
+        // For details, see comment above excludeOutsideFiles in
+        // https://devtopia.esri.com/WebGIS/arcgis-web-components/blob/main/packages/support-packages/lit-compiler/src/types/textTransformers.ts
+        rootDir: ".",
+        ...dtsOptions.compilerOptions
+      },
+      /**
+       * Do not emit any .d.ts files for files outside the dist directory
+       * (i.e vite.config.ts, storybook stories and etc)
+       * This also applies for references to node_modules/.../components.d.ts files in
+       * tsconfig.json - these must be included in TypeScript program to provide
+       * types, but should not be re-emitted during build.
+       */
+      beforeWriteFile: async (filePath, content) => {
+        if (filePath.startsWith(distSrc) && !shouldSkip(filePath)) {
+          const baseBeforeWriteFile = dtsOptions?.beforeWriteFile ?? ((filePath2, content2) => ({ filePath: filePath2, content: content2 }));
+          return await baseBeforeWriteFile(`${dist}${filePath.slice(distSrc.length)}`, content);
+        } else {
+          return false;
+        }
+      },
+      afterDiagnostic(diagnostics) {
+        const hasErrors = diagnostics.length > 0;
+        const isBuilding = command === "build";
+        const stopBuild = hasErrors && isBuilding;
+        if (stopBuild) {
+          throw new Error("TypeScript errors reported. See error messages above");
+        }
+        return dtsOptions?.afterDiagnostic?.(diagnostics);
+      }
+    })
+  ];
+}
+function shouldSkip(id) {
+  return id.includes("__test") || id.includes(".e2e.") || id.includes(".spec.") || id.includes(".test.") || id.includes(".stories.");
+}
+const stringToStartsWithGlob = (option) => option ? typeof option === "string" ? new RegExp(`^${option.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&")}`, "u") : option : void 0;
 export {
   asyncFindPath,
   asyncRetrievePackageJson,
@@ -188,6 +283,8 @@ export {
   path,
   retrievePackageJson,
   sh,
+  stringToStartsWithGlob,
   toPosixPathSeparators,
-  toSystemPathSeparators
+  toSystemPathSeparators,
+  vitePresetPlugin
 };

package/dist/packageJson.d.cts

@@ -0,0 +1,39 @@
+/**
+ * A subset of the package.json typing that is interesting to Lumina.
+ *
+ * The full package.json type is insanely large (20k lines):
+ * https://github.com/ffflorian/schemastore-updater/blob/main/schemas/package/index.d.ts#L20067
+ */
+export type MiniPackageJson = {
+    "name": string;
+    "version": string;
+    "private"?: boolean;
+    "type"?: "commonjs" | "module";
+    "publishConfig"?: {
+        access?: string;
+        registry?: string;
+    };
+    "files"?: string[];
+    "dependencies"?: Record<string, string | undefined>;
+    "devDependencies"?: Record<string, string | undefined>;
+    "peerDependencies"?: Record<string, string | undefined>;
+    "peerDependenciesMeta"?: Record<string, {
+        optional?: boolean;
+    }>;
+    "css.customData"?: string[];
+    "customElements"?: string;
+    "html.customData"?: string[];
+    "web-types"?: string;
+    "exports"?: Record<string, Record<string, string> | string>;
+};
+export declare function retrievePackageJson(location?: string): MiniPackageJson;
+export declare function asyncRetrievePackageJson(location?: string): Promise<MiniPackageJson>;
+/**
+ * Returns an absolute path to the root of a package in node_modules, without
+ * trailing slash.
+ */
+export declare function fetchPackageLocation(packageName: string, cwd?: string): Promise<string>;
+/**
+ * Detect if current repository/monorepo uses npm, yarn or pnpm
+ */
+export declare function detectPackageManager(cwd?: string): string;

package/dist/packageJson.d.ts

@@ -0,0 +1,39 @@
+/**
+ * A subset of the package.json typing that is interesting to Lumina.
+ *
+ * The full package.json type is insanely large (20k lines):
+ * https://github.com/ffflorian/schemastore-updater/blob/main/schemas/package/index.d.ts#L20067
+ */
+export type MiniPackageJson = {
+    "name": string;
+    "version": string;
+    "private"?: boolean;
+    "type"?: "commonjs" | "module";
+    "publishConfig"?: {
+        access?: string;
+        registry?: string;
+    };
+    "files"?: string[];
+    "dependencies"?: Record<string, string | undefined>;
+    "devDependencies"?: Record<string, string | undefined>;
+    "peerDependencies"?: Record<string, string | undefined>;
+    "peerDependenciesMeta"?: Record<string, {
+        optional?: boolean;
+    }>;
+    "css.customData"?: string[];
+    "customElements"?: string;
+    "html.customData"?: string[];
+    "web-types"?: string;
+    "exports"?: Record<string, Record<string, string> | string>;
+};
+export declare function retrievePackageJson(location?: string): MiniPackageJson;
+export declare function asyncRetrievePackageJson(location?: string): Promise<MiniPackageJson>;
+/**
+ * Returns an absolute path to the root of a package in node_modules, without
+ * trailing slash.
+ */
+export declare function fetchPackageLocation(packageName: string, cwd?: string): Promise<string>;
+/**
+ * Detect if current repository/monorepo uses npm, yarn or pnpm
+ */
+export declare function detectPackageManager(cwd?: string): string;

package/dist/path.d.cts

@@ -0,0 +1,22 @@
+import { default as posix } from 'path/posix';
+/**
+ * This is called "isPosix" rather than "isNotWindows" because even if we are
+ * on Windows, we could be running in a POSIX environment (e.g. WSL2)
+ */
+export declare const isPosix: boolean;
+export declare const toPosixPathSeparators: (relativePath: string) => string;
+export declare const normalizePath: (relativePath: string) => string;
+/**
+ * On Windows, replace all `/` in the path back with `\\`. Do this only if you
+ * wish to output the path in the console or error message.
+ * On POSIX system (macOS, Linux, ...), this does not change the path (because
+ * inside the compiler we use `/` everywhere).
+ */
+export declare const toSystemPathSeparators: (relativePath: string) => string;
+export declare const getCwd: () => string;
+export declare const path: typeof posix & {
+    sep: "/";
+};
+export declare const exportsForTests: {
+    toWin32PathSeparators: (relativePath: string) => string;
+};

package/dist/path.d.ts

@@ -0,0 +1,22 @@
+import { default as posix } from 'path/posix';
+/**
+ * This is called "isPosix" rather than "isNotWindows" because even if we are
+ * on Windows, we could be running in a POSIX environment (e.g. WSL2)
+ */
+export declare const isPosix: boolean;
+export declare const toPosixPathSeparators: (relativePath: string) => string;
+export declare const normalizePath: (relativePath: string) => string;
+/**
+ * On Windows, replace all `/` in the path back with `\\`. Do this only if you
+ * wish to output the path in the console or error message.
+ * On POSIX system (macOS, Linux, ...), this does not change the path (because
+ * inside the compiler we use `/` everywhere).
+ */
+export declare const toSystemPathSeparators: (relativePath: string) => string;
+export declare const getCwd: () => string;
+export declare const path: typeof posix & {
+    sep: "/";
+};
+export declare const exportsForTests: {
+    toWin32PathSeparators: (relativePath: string) => string;
+};

package/dist/vite.d.cts

@@ -0,0 +1,24 @@
+import { Plugin } from 'vite';
+import { default as dts } from 'vite-plugin-dts';
+/**
+ * Vite preset for all our support packages:
+ * - externalizes all devDependencies (using `rollup-plugin-node-externals`)
+ * - generates type declarations (using `vite-plugin-dts`)
+ */
+export declare function vitePresetPlugin({ externalize, dtsOptions, }?: {
+    /** The list of dependencies to externalize besides devDependencies */
+    externalize?: string[];
+    /** Additional options for `vite-plugin-dts` */
+    dtsOptions?: Parameters<typeof dts>[0];
+}): [Plugin, Promise<Plugin>, Plugin];
+/**
+ * By default this plugin converts string values to RegExp that only matches if
+ * path is "equal" not "starts with", which is not intuitive.
+ *
+ * I.e, this would only exclude "monaco-editor", not any
+ * "monaco-editor/sub-path" by default:
+ * "bundleIn": ["monaco-editor"]
+ *
+ * We fix it to match using "starts with" instead
+ */
+export declare const stringToStartsWithGlob: (option: RegExp | string | false | null | undefined) => RegExp | undefined;

package/dist/vite.d.ts

@@ -0,0 +1,24 @@
+import { Plugin } from 'vite';
+import { default as dts } from 'vite-plugin-dts';
+/**
+ * Vite preset for all our support packages:
+ * - externalizes all devDependencies (using `rollup-plugin-node-externals`)
+ * - generates type declarations (using `vite-plugin-dts`)
+ */
+export declare function vitePresetPlugin({ externalize, dtsOptions, }?: {
+    /** The list of dependencies to externalize besides devDependencies */
+    externalize?: string[];
+    /** Additional options for `vite-plugin-dts` */
+    dtsOptions?: Parameters<typeof dts>[0];
+}): [Plugin, Promise<Plugin>, Plugin];
+/**
+ * By default this plugin converts string values to RegExp that only matches if
+ * path is "equal" not "starts with", which is not intuitive.
+ *
+ * I.e, this would only exclude "monaco-editor", not any
+ * "monaco-editor/sub-path" by default:
+ * "bundleIn": ["monaco-editor"]
+ *
+ * We fix it to match using "starts with" instead
+ */
+export declare const stringToStartsWithGlob: (option: RegExp | string | false | null | undefined) => RegExp | undefined;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arcgis/components-build-utils",
-  "version": "4.33.0-next.13",
+  "version": "4.33.0-next.133",
   "description": "Collection of common internal build-time patterns and utilities for ArcGIS Maps SDK for JavaScript components.",
   "homepage": "https://developers.arcgis.com/javascript/latest/",
   "type": "module",
@@ -26,7 +26,10 @@
     "chalk": "^5.3.0",
     "commander": "^11.1.0",
     "glob": "^11.0.0",
+    "rollup-plugin-node-externals": "^8.0.0",
     "split2": "^4.2.0",
-    "tslib": "^2.7.0"
+    "tslib": "^2.8.1",
+    "vite": "^6.3.4",
+    "vite-plugin-dts": "^4.5.3"
   }
 }