@arcgis/components-build-utils 4.33.0-next.16 → 4.33.0-next.160

package/dist/index.cjs

@@ -5,10 +5,6 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
     for (let key of __getOwnPropNames(from))
@@ -25,55 +21,37 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
   mod
 ));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/index.ts
-var src_exports = {};
-__export(src_exports, {
-  asyncFindPath: () => asyncFindPath,
-  asyncRetrievePackageJson: () => asyncRetrievePackageJson,
-  createFileIfNotExists: () => createFileIfNotExists,
-  detectPackageManager: () => detectPackageManager,
-  existsAsync: () => existsAsync,
-  exportsForTests: () => exportsForTests,
-  fetchPackageLocation: () => fetchPackageLocation,
-  findPath: () => findPath,
-  getCwd: () => getCwd,
-  gitIgnoreToGlob: () => gitIgnoreToGlob,
-  isPosix: () => isPosix,
-  normalizePath: () => normalizePath,
-  path: () => path,
-  retrievePackageJson: () => retrievePackageJson,
-  sh: () => sh,
-  toPosixPathSeparators: () => toPosixPathSeparators,
-  toSystemPathSeparators: () => toSystemPathSeparators
-});
-module.exports = __toCommonJS(src_exports);
-
-// src/file.ts
-var import_node_fs = require("fs");
-var import_promises = require("fs/promises");
-var import_node_child_process = require("child_process");
-var import_path = require("path");
-var import_node_url = require("url");
-var existsAsync = async (file) => await (0, import_promises.access)(file, import_promises.constants.F_OK).then(() => true).catch(() => false);
-var sh = (command, cwd) => (0, import_node_child_process.execSync)(command.trim(), { encoding: "utf8", cwd }).trim();
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const node_fs = require("node:fs");
+const promises = require("node:fs/promises");
+const node_child_process = require("node:child_process");
+const node_path = require("node:path");
+const node_url = require("node:url");
+const posix = require("node:path/posix");
+const win32 = require("node:path/win32");
+const dts = require("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) => node_fs.access(file, promises.constants.F_OK, (error) => resolve2(!error)))
+);
+const sh = (command, cwd) => node_child_process.execSync(command.trim(), { encoding: "utf8", cwd }).trim();
 async function createFileIfNotExists(filePath, content) {
-  await (0, import_promises.mkdir)((0, import_path.dirname)(filePath), { recursive: true });
+  await promises.mkdir(node_path.dirname(filePath), { recursive: true });
   if (!await existsAsync(filePath)) {
-    await (0, import_promises.writeFile)(filePath, content, { encoding: "utf8" });
+    await promises.writeFile(filePath, content, { encoding: "utf8" });
   }
 }
 function findPath(target, startDirectory = process.cwd()) {
-  const resolvedStartDirectory = startDirectory.startsWith("file:///") ? (0, import_path.dirname)((0, import_node_url.fileURLToPath)(startDirectory)) : (0, import_path.resolve)(startDirectory);
-  const parentPath = resolvedStartDirectory.split(import_path.sep);
+  const resolvedStartDirectory = startDirectory.startsWith("file:///") ? node_path.dirname(node_url.fileURLToPath(startDirectory)) : node_path.resolve(startDirectory);
+  const parentPath = resolvedStartDirectory.split(node_path.sep);
   while (parentPath.length > 2) {
-    const fullPath = (0, import_path.join)(
-      ...import_path.sep === "/" ? ["/"] : [],
+    const fullPath = node_path.join(
+      ...node_path.sep === "/" ? ["/"] : [],
       ...parentPath,
       target
     );
-    if ((0, import_node_fs.existsSync)(fullPath)) {
+    if (node_fs.existsSync(fullPath)) {
       return fullPath;
     }
     parentPath.pop();
@@ -81,11 +59,11 @@ function findPath(target, startDirectory = process.cwd()) {
   return void 0;
 }
 async function asyncFindPath(target, startDirectory = process.cwd()) {
-  const resolvedStartDirectory = startDirectory.startsWith("file:///") ? (0, import_path.dirname)((0, import_node_url.fileURLToPath)(startDirectory)) : (0, import_path.resolve)(startDirectory);
-  const parentPath = resolvedStartDirectory.split(import_path.sep);
+  const resolvedStartDirectory = startDirectory.startsWith("file:///") ? node_path.dirname(node_url.fileURLToPath(startDirectory)) : node_path.resolve(startDirectory);
+  const parentPath = resolvedStartDirectory.split(node_path.sep);
   while (parentPath.length > 2) {
-    const fullPath = (0, import_path.join)(
-      ...import_path.sep === "/" ? ["/"] : [],
+    const fullPath = node_path.join(
+      ...node_path.sep === "/" ? ["/"] : [],
       ...parentPath,
       target
     );
@@ -96,9 +74,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);
@@ -118,56 +94,47 @@ function fixMatchFilesSyntax(pattern) {
   }
   return pattern.endsWith("/*") ? `${pattern}*` : pattern.endsWith("/") ? `${pattern}**` : `${pattern}/**`;
 }
-
-// src/path.ts
-var import_path2 = require("path");
-var import_posix = __toESM(require("path/posix"), 1);
-var import_win32 = __toESM(require("path/win32"), 1);
-var isPosix = import_path2.sep === import_posix.default.sep;
-var toPosixPathSeparators = (relativePath) => relativePath.includes(import_win32.default.sep) ? relativePath.replaceAll(import_win32.default.sep, import_posix.default.sep) : relativePath;
-var normalizePath = isPosix ? (path2) => path2 : toPosixPathSeparators;
-var toWin32PathSeparators = (relativePath) => relativePath.includes(import_posix.default.sep) ? relativePath.replaceAll(import_posix.default.sep, import_win32.default.sep) : relativePath;
-var toSystemPathSeparators = isPosix ? (path2) => path2 : toWin32PathSeparators;
-var getCwd = isPosix ? process.cwd : () => toPosixPathSeparators(process.cwd());
-var path = isPosix ? import_posix.default : {
-  ...import_win32.default,
-  sep: import_posix.default.sep,
+const isPosix = node_path.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) {
-    const result = import_win32.default.join(...paths);
+    const result = win32.join(...paths);
     return toPosixPathSeparators(result);
   },
   normalize(path2) {
-    const result = import_win32.default.normalize(path2);
+    const result = win32.normalize(path2);
     return toPosixPathSeparators(result);
   },
   relative(from, to) {
-    const result = import_win32.default.relative(from, to);
+    const result = win32.relative(from, to);
     return toPosixPathSeparators(result);
   },
   dirname(path2) {
-    const result = import_win32.default.dirname(path2);
+    const result = win32.dirname(path2);
     return toPosixPathSeparators(result);
   },
   resolve(...paths) {
-    const result = import_win32.default.resolve(...paths);
+    const result = win32.resolve(...paths);
     return toPosixPathSeparators(result);
   },
   toNamespacedPath(path2) {
-    const result = import_win32.default.toNamespacedPath(path2);
+    const result = win32.toNamespacedPath(path2);
     return toPosixPathSeparators(result);
   }
 };
-var exportsForTests = { toWin32PathSeparators };
-
-// src/packageJson.ts
-var import_promises2 = require("fs/promises");
-var import_node_fs2 = require("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((0, import_node_fs2.readFileSync)(packageJsonPath, "utf-8"));
+  cachedPackageJson[packageJsonPath] ??= JSON.parse(node_fs.readFileSync(packageJsonPath, "utf-8"));
   return cachedPackageJson[packageJsonPath];
 }
 async function asyncRetrievePackageJson(location = getCwd()) {
@@ -180,9 +147,9 @@ async function asyncRetrievePackageJson(location = getCwd()) {
   cachedPackageJson[packageJsonPath] ??= result;
   return result;
 }
-var asyncReadPackageJson = async (location) => JSON.parse(await (0, import_promises2.readFile)(location, "utf-8"));
-var cachedPackageLocation = {};
-var cachedPackageLocationPromises = {};
+const asyncReadPackageJson = async (location) => JSON.parse(await promises.readFile(location, "utf-8"));
+const cachedPackageLocation = {};
+const cachedPackageLocationPromises = {};
 async function fetchPackageLocation(packageName, cwd) {
   if (packageName in cachedPackageLocation) {
     return cachedPackageLocation[packageName];
@@ -192,8 +159,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);
@@ -209,10 +176,10 @@ function detectPackageManager(cwd = process.cwd()) {
     while (pathParts.length > 1) {
       const packageJson = path.join(pathParts.join(path.sep), "package.json");
       pathParts.pop();
-      if (!(0, import_node_fs2.existsSync)(packageJson)) {
+      if (!node_fs.existsSync(packageJson)) {
         continue;
       }
-      const contents = JSON.parse((0, import_node_fs2.readFileSync)(packageJson, "utf8"));
+      const contents = JSON.parse(node_fs.readFileSync(packageJson, "utf8"));
       if (typeof contents !== "object" || Array.isArray(contents)) {
         continue;
       }
@@ -224,23 +191,122 @@ function detectPackageManager(cwd = process.cwd()) {
   packageManager ??= "npm";
   return packageManager;
 }
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  asyncFindPath,
-  asyncRetrievePackageJson,
-  createFileIfNotExists,
-  detectPackageManager,
-  existsAsync,
-  exportsForTests,
-  fetchPackageLocation,
-  findPath,
-  getCwd,
-  gitIgnoreToGlob,
-  isPosix,
-  normalizePath,
-  path,
-  retrievePackageJson,
-  sh,
-  toPosixPathSeparators,
-  toSystemPathSeparators
-});
+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 promises.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;
+exports.asyncFindPath = asyncFindPath;
+exports.asyncRetrievePackageJson = asyncRetrievePackageJson;
+exports.createFileIfNotExists = createFileIfNotExists;
+exports.detectPackageManager = detectPackageManager;
+exports.existsAsync = existsAsync;
+exports.exportsForTests = exportsForTests;
+exports.fetchPackageLocation = fetchPackageLocation;
+exports.findPath = findPath;
+exports.getCwd = getCwd;
+exports.gitIgnoreToGlob = gitIgnoreToGlob;
+exports.isPosix = isPosix;
+exports.normalizePath = normalizePath;
+exports.path = path;
+exports.retrievePackageJson = retrievePackageJson;
+exports.sh = sh;
+exports.stringToStartsWithGlob = stringToStartsWithGlob;
+exports.toPosixPathSeparators = toPosixPathSeparators;
+exports.toSystemPathSeparators = toSystemPathSeparators;
+exports.vitePresetPlugin = vitePresetPlugin;

package/dist/index.d.cts

@@ -1,71 +1,5 @@
-import posix from 'path/posix';
-
-declare const existsAsync: (file: string) => Promise<boolean>;
-/** Wrapper for execSync to execute shell commands */
-declare const sh: (command: string, cwd?: string) => string;
-declare function createFileIfNotExists(filePath: string, content: string): Promise<void>;
-/**
- * Climb the directory tree upward, until found a directory that contains the
- * target file, and return resulting full path
- */
-declare function findPath(target: string, startDirectory?: string): string | undefined;
-/**
- * Climb the directory tree upward, until found a directory that contains the
- * target file, and return resulting full path
- */
-declare function asyncFindPath(target: string, startDirectory?: string): Promise<string | undefined>;
-
-declare const gitIgnoreToGlob: (pattern: string) => string;
-
-/**
- * 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)
- */
-declare const isPosix: boolean;
-declare const toPosixPathSeparators: (relativePath: string) => string;
-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).
- */
-declare const toSystemPathSeparators: (relativePath: string) => string;
-declare const getCwd: () => string;
-declare const path: typeof posix & {
-    sep: "/";
-};
-declare const exportsForTests: {
-    toWin32PathSeparators: (relativePath: string) => string;
-};
-
-/**
- * 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
- */
-type MiniPackageJson = {
-    "name": string;
-    "version": string;
-    "dependencies"?: Record<string, string | undefined>;
-    "devDependencies"?: Record<string, string | undefined>;
-    "peerDependencies"?: Record<string, string | undefined>;
-    "css.customData"?: string[];
-    "customElements"?: string;
-    "html.customData"?: string[];
-    "web-types"?: string;
-};
-declare function retrievePackageJson(location?: string): MiniPackageJson;
-declare function asyncRetrievePackageJson(location?: string): Promise<MiniPackageJson>;
-/**
- * Returns an absolute path to the root of a package in node_modules, without
- * trailing slash.
- */
-declare function fetchPackageLocation(packageName: string, cwd?: string): Promise<string>;
-/**
- * Detect if current repository/monorepo uses npm, yarn or pnpm
- */
-declare function detectPackageManager(cwd?: string): string;
-
-export { type MiniPackageJson, asyncFindPath, asyncRetrievePackageJson, createFileIfNotExists, detectPackageManager, existsAsync, exportsForTests, fetchPackageLocation, findPath, getCwd, gitIgnoreToGlob, isPosix, normalizePath, path, retrievePackageJson, sh, toPosixPathSeparators, toSystemPathSeparators };
+export * from './file';
+export * from './glob';
+export * from './path';
+export * from './packageJson';
+export * from './vite';

package/dist/index.d.ts

@@ -1,71 +1,5 @@
-import posix from 'path/posix';
-
-declare const existsAsync: (file: string) => Promise<boolean>;
-/** Wrapper for execSync to execute shell commands */
-declare const sh: (command: string, cwd?: string) => string;
-declare function createFileIfNotExists(filePath: string, content: string): Promise<void>;
-/**
- * Climb the directory tree upward, until found a directory that contains the
- * target file, and return resulting full path
- */
-declare function findPath(target: string, startDirectory?: string): string | undefined;
-/**
- * Climb the directory tree upward, until found a directory that contains the
- * target file, and return resulting full path
- */
-declare function asyncFindPath(target: string, startDirectory?: string): Promise<string | undefined>;
-
-declare const gitIgnoreToGlob: (pattern: string) => string;
-
-/**
- * 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)
- */
-declare const isPosix: boolean;
-declare const toPosixPathSeparators: (relativePath: string) => string;
-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).
- */
-declare const toSystemPathSeparators: (relativePath: string) => string;
-declare const getCwd: () => string;
-declare const path: typeof posix & {
-    sep: "/";
-};
-declare const exportsForTests: {
-    toWin32PathSeparators: (relativePath: string) => string;
-};
-
-/**
- * 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
- */
-type MiniPackageJson = {
-    "name": string;
-    "version": string;
-    "dependencies"?: Record<string, string | undefined>;
-    "devDependencies"?: Record<string, string | undefined>;
-    "peerDependencies"?: Record<string, string | undefined>;
-    "css.customData"?: string[];
-    "customElements"?: string;
-    "html.customData"?: string[];
-    "web-types"?: string;
-};
-declare function retrievePackageJson(location?: string): MiniPackageJson;
-declare function asyncRetrievePackageJson(location?: string): Promise<MiniPackageJson>;
-/**
- * Returns an absolute path to the root of a package in node_modules, without
- * trailing slash.
- */
-declare function fetchPackageLocation(packageName: string, cwd?: string): Promise<string>;
-/**
- * Detect if current repository/monorepo uses npm, yarn or pnpm
- */
-declare function detectPackageManager(cwd?: string): string;
-
-export { type MiniPackageJson, asyncFindPath, asyncRetrievePackageJson, createFileIfNotExists, detectPackageManager, existsAsync, exportsForTests, fetchPackageLocation, findPath, getCwd, gitIgnoreToGlob, isPosix, normalizePath, path, retrievePackageJson, sh, toPosixPathSeparators, toSystemPathSeparators };
+export * from './file';
+export * from './glob';
+export * from './path';
+export * from './packageJson';
+export * from './vite';