@arcgis/node-toolkit 5.2.0-next.31

package/LICENSE.md

@@ -0,0 +1,17 @@
+# Licensing
+
+COPYRIGHT © Esri
+
+All rights reserved under the copyright laws of the United States and applicable international laws, treaties, and conventions.
+
+This material is licensed for use under the [Esri Master License Agreement (MLA)](https://www.esri.com/content/dam/esrisites/en-us/media/legal/ma-full/ma-full.pdf), and is bound by the terms of that agreement.
+You may redistribute and use this code without modification, provided you adhere to the terms of the MLA and include this copyright notice.
+
+For additional information, contact:
+Environmental Systems Research Institute, Inc.
+Attn: Contracts and Legal Services Department
+380 New York Street
+Redlands, California, USA 92373
+USA
+
+email: legal@esri.com

package/README.md

@@ -0,0 +1,12 @@
+# ArcGIS Maps SDK for JavaScript - Node Utils
+
+**No Esri Technical Support included.**
+
+Package that is part of the [ArcGIS Maps SDK for JavaScript](https://developers.arcgis.com/javascript).
+
+It is not intended to be used directly, but rather used as a dependency by other packages in the SDK.
+
+## License
+
+This package is licensed under the terms described in the `LICENSE.md` file, located in the root of the package, and at https://js.arcgis.com/5.1/LICENSE.txt.
+For third party notices, see https://js.arcgis.com/5.1/third-party-notices.txt.

package/dist/file.d.ts

@@ -0,0 +1,35 @@
+import { ExecSyncOptionsWithStringEncoding, SpawnSyncOptionsWithStringEncoding } from 'node:child_process';
+/**
+ * Asynchronously check if a file or directory exists.
+ * Using un-promisified version because promises version creates exceptions
+ * which interferes with debugging when "Pause on caught exceptions" is enabled
+ */
+export declare const existsAsync: (file: string) => Promise<boolean>;
+/**
+ * Synchronously execute a shell command and return the output.
+ */
+export declare function sh(command: string, options?: Partial<ExecSyncOptionsWithStringEncoding>): string;
+/**
+ * Asynchronously execute a shell command and return the output.
+ */
+export declare function asyncSh(command: string, options?: Partial<ExecSyncOptionsWithStringEncoding>): Promise<string>;
+/**
+ * Synchronously execute a command without shell interpolation and return the output.
+ */
+export declare function sp(command: string, args: string[], options?: Partial<SpawnSyncOptionsWithStringEncoding>): string;
+/**
+ * Create a file with the specified content if it does not already exist.
+ */
+export declare function createFileIfNotExists(filePath: string, content: string): Promise<void>;
+/**
+ * Climb the directory tree upward, until it founds a directory that contains the
+ * target file, and return resulting full path.
+ * Returns `undefined` if the file is not found.
+ */
+export declare function findPath(target: string, startDirectory?: string): string | undefined;
+/**
+ * Asynchronously climb the directory tree upward, until it founds a directory that contains the
+ * target file, and return resulting full path.
+ * Returns `undefined` if the file is not found.
+ */
+export declare function asyncFindPath(target: string, startDirectory?: string): Promise<string | undefined>;

package/dist/file.js

@@ -0,0 +1,113 @@
+import { access, existsSync } from "node:fs";
+import { constants, mkdir, writeFile } from "node:fs/promises";
+import { dirname, resolve, sep, join } from "path";
+import { fileURLToPath } from "node:url";
+import { execSync, exec, spawnSync } from "node:child_process";
+import { styleText } from "node:util";
+const existsAsync = async (file) => (
+  //#endregion existsAsync
+  await new Promise((resolve2) => access(file, constants.F_OK, (error) => resolve2(!error)))
+);
+function sh(command, options = {}) {
+  try {
+    const normalizedOptions = { encoding: "utf8", ...options };
+    return execSync(command.trim(), normalizedOptions).trim();
+  } catch (error) {
+    makeExecErrorReadable(error);
+    throw error;
+  }
+}
+async function asyncSh(command, options = {}) {
+  const normalizedOptions = { encoding: "utf8", ...options };
+  return await new Promise((resolve2, reject) => {
+    exec(command.trim(), normalizedOptions, (error, stdout, stderr) => {
+      if (error) {
+        makeExecErrorReadable(error);
+        reject(error);
+        return;
+      }
+      resolve2(stdout.trim() || stderr.trim());
+    });
+  });
+}
+function sp(command, args, options = {}) {
+  const normalizedOptions = { encoding: "utf8", ...options };
+  const result = spawnSync(command, args, normalizedOptions);
+  if (result.error) {
+    throw result.error;
+  }
+  const output = `${result.stdout ?? ""}${result.stderr ?? ""}`.trim();
+  const exitCode = result.status ?? 0;
+  if (exitCode !== 0) {
+    throw new Error(
+      `Command failed with exit code ${String(exitCode)}: ${command} ${args.join(" ")}
+${output}`.trim()
+    );
+  }
+  return output;
+}
+function makeExecErrorReadable(error) {
+  if (error instanceof Error && error.stack && "output" in error && Array.isArray(error.output) && "status" in error) {
+    const stackIndex = error.stack.indexOf("\n    at ");
+    if (stackIndex !== -1) {
+      const output = error.output.filter(Boolean).join("\n").trim();
+      const newHeader = `${styleText("red", error.message)} (exit code: ${String(error.status)})
+${output}`;
+      const oldStackFrames = error.stack.substring(stackIndex);
+      error.stack = `Error: ${newHeader}${oldStackFrames}`;
+    }
+    Object.defineProperties(error, {
+      output: { enumerable: false },
+      stdout: { enumerable: false },
+      stderr: { enumerable: false },
+      signal: { enumerable: false },
+      status: { enumerable: false },
+      pid: { enumerable: false },
+      stdio: { enumerable: false }
+    });
+  }
+}
+async function createFileIfNotExists(filePath, content) {
+  await mkdir(dirname(filePath), { recursive: true });
+  if (!await existsAsync(filePath)) {
+    await writeFile(filePath, content, { encoding: "utf8" });
+  }
+}
+function* getSearchCandidates(target, startDirectory) {
+  const resolvedStartDirectory = startDirectory.startsWith("file:///") ? dirname(fileURLToPath(startDirectory)) : resolve(startDirectory);
+  const parentPath = resolvedStartDirectory.split(sep);
+  while (parentPath.length > searchStopIndex) {
+    yield join(
+      ...sep === "/" ? ["/"] : [],
+      ...parentPath,
+      target
+    );
+    parentPath.pop();
+  }
+}
+function findPath(target, startDirectory = process.cwd()) {
+  for (const fullPath of getSearchCandidates(target, startDirectory)) {
+    if (existsSync(fullPath)) {
+      return fullPath;
+    }
+  }
+  return void 0;
+}
+const searchStopIndex = 0;
+async function asyncFindPath(target, startDirectory = process.cwd()) {
+  for (const fullPath of getSearchCandidates(target, startDirectory)) {
+    if (await existsAsync(fullPath)) {
+      return fullPath;
+    }
+  }
+  return void 0;
+}
+export {
+  asyncFindPath,
+  asyncSh,
+  createFileIfNotExists,
+  existsAsync,
+  findPath,
+  sh,
+  sp
+};

package/dist/glob.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Read `.gitignore` files and convert it to globs that are accepted by ESLint
+ *
+ * @example
+ * ```ts
+ * // eslint.config.js
+ * import { gitIgnoreFileToGlobs } from "@arcgis/node-toolkit/glob";
+ * import { globalIgnores } from "eslint/config";
+ *
+ * export default [
+ *   globalIgnores([
+ *     ...gitIgnoreFileToGlobs(import.meta.dirname + "/.gitignore"),
+ *     ...gitIgnoreFileToGlobs(import.meta.dirname + "/.prettierignore"),
+ *   ]),
+ *   // ...
+ * ];
+ * ```
+ */
+export declare function gitIgnoreFileToGlobs(filePath: string): string[];
+/**
+ * @deprecated Use gitIgnoreFileToGlobs from "@arcgis/node-toolkit/glob"
+ * instead
+ */
+export declare const gitIgnoreToGlob: (pattern: string) => string;

package/dist/glob.js

@@ -0,0 +1,28 @@
+import { readFileSync } from "node:fs";
+function gitIgnoreFileToGlobs(filePath) {
+  return readFileSync(filePath, "utf8").split("\n").filter((line) => line.trim().length > 0 && !line.trim().startsWith("#")).map(gitIgnoreToGlob);
+}
+const gitIgnoreToGlob = (pattern) => fixAbsoluteSyntax(fixMatchFilesSyntax(pattern));
+function fixAbsoluteSyntax(pattern) {
+  if (pattern.startsWith("/")) {
+    return pattern.slice(1);
+  }
+  if (pattern.startsWith("!/")) {
+    return `!${pattern.slice(2)}`;
+  }
+  const isAlreadyCorrect = pattern.startsWith("**") || pattern.startsWith("!**");
+  const basePattern = pattern.startsWith("!") ? pattern.slice(1) : pattern;
+  return isAlreadyCorrect ? pattern : `${pattern.startsWith("!") ? "!" : ""}**/${basePattern}`;
+}
+function fixMatchFilesSyntax(pattern) {
+  const base = pattern.split("/").at(-1);
+  const isAlreadyCorrect = pattern.endsWith("**") || pattern.includes("{") || base?.includes(".");
+  if (isAlreadyCorrect) {
+    return pattern;
+  }
+  return pattern.endsWith("/*") ? `${pattern}*` : pattern.endsWith("/") ? `${pattern}**` : `${pattern}/**`;
+}
+export {
+  gitIgnoreFileToGlobs,
+  gitIgnoreToGlob
+};

package/dist/packageJson.d.ts

@@ -0,0 +1,64 @@
+/**
+ * A subset of the package.json typing.
+ * Useful for the majority of cases where you just need to read the name, version, and dependencies of a package.json file.
+ *
+ * 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 PackageJson = {
+    "name": string;
+    "version": string;
+    "private"?: boolean;
+    "type"?: "commonjs" | "module";
+    "main"?: string;
+    "module"?: string;
+    "types"?: string;
+    "files"?: string[];
+    "bin"?: Record<string, string> | string;
+    "man"?: string[] | string;
+    /**
+     * @see https://pnpm.io/package_json#publishconfigdirectory
+     */
+    "publishConfig"?: {
+        directory?: string;
+        linkDirectory?: boolean;
+    };
+    "dependencies"?: Record<string, string>;
+    "devDependencies"?: Record<string, string>;
+    "peerDependencies"?: Record<string, string>;
+    "peerDependenciesMeta"?: Record<string, {
+        optional?: boolean;
+    }>;
+    "optionalDependencies"?: Record<string, string>;
+    "css.customData"?: string[];
+    "customElements"?: string;
+    "html.customData"?: string[];
+    "web-types"?: string;
+    "exports"?: Record<string, Record<string, string> | string>;
+    "engines"?: {
+        node?: string;
+    };
+    "scripts"?: Record<string, string>;
+    "packageManager"?: string;
+};
+/**
+ * Synchronously retrieves the package.json file for the current project or a specified location.
+ * If the location is not specified, it will search for the package.json file starting from the current working directory.
+ * This function caches the package.json file for future calls to avoid unnecessary file system reads.
+ */
+export declare function retrievePackageJson(location?: string): PackageJson;
+/**
+ * Asynchronously retrieves the package.json file for the current project or a specified location.
+ * If the location is not specified, it will search for the package.json file starting from the current working directory.
+ * This function caches the package.json file for future calls to avoid unnecessary file system reads.
+ */
+export declare function asyncRetrievePackageJson(location?: string): Promise<PackageJson>;
+/**
+ * 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, pnpm, or yarn
+ */
+export declare function detectPackageManager(cwd?: string): string;

package/dist/packageJson.js

@@ -0,0 +1,73 @@
+import { readFile } from "node:fs/promises";
+import { path } from "./path.js";
+import { asyncFindPath, findPath } from "./file.js";
+import { existsSync, readFileSync } from "node:fs";
+const cachedPackageJson = {};
+const cachedPackageJsonPromises = {};
+let rootPackageJsonLocation;
+function retrievePackageJson(location) {
+  const packageJsonPath = getPackageJsonPath(location);
+  cachedPackageJson[packageJsonPath] ??= JSON.parse(readFileSync(packageJsonPath, "utf-8"));
+  return cachedPackageJson[packageJsonPath];
+}
+async function asyncRetrievePackageJson(location) {
+  const packageJsonPath = getPackageJsonPath(location);
+  if (packageJsonPath in cachedPackageJson) {
+    return cachedPackageJson[packageJsonPath];
+  }
+  cachedPackageJsonPromises[packageJsonPath] ??= asyncReadPackageJson(packageJsonPath);
+  const result = await cachedPackageJsonPromises[packageJsonPath];
+  cachedPackageJson[packageJsonPath] ??= result;
+  return result;
+}
+const getPackageJsonPath = (location) => location ? path.resolve(location, "package.json") : rootPackageJsonLocation ??= findPath("package.json");
+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];
+  }
+  cachedPackageLocationPromises[packageName] ??= asyncFindPath(
+    path.join("node_modules", packageName, "package.json"),
+    cwd
+  ).then((packageJsonLocation) => {
+    if (packageJsonLocation === void 0) {
+      throw Error(
+        `@arcgis/node-toolkit: Unable to resolve package.json location for "${packageName}" package. Current working directory: ${process.cwd()}`
+      );
+    }
+    return path.dirname(packageJsonLocation);
+  });
+  const result = await cachedPackageLocationPromises[packageName];
+  cachedPackageLocation[packageName] ??= result;
+  return cachedPackageLocation[packageName];
+}
+function detectPackageManager(cwd = process.cwd()) {
+  let packageManager = void 0;
+  {
+    const pathParts = path.resolve(cwd).split(path.sep);
+    while (pathParts.length > 1) {
+      const packageJson = path.join(pathParts.join(path.sep), "package.json");
+      pathParts.pop();
+      if (!existsSync(packageJson)) {
+        continue;
+      }
+      const contents = JSON.parse(readFileSync(packageJson, "utf8"));
+      if (typeof contents !== "object" || Array.isArray(contents)) {
+        continue;
+      }
+      if (typeof contents.packageManager === "string") {
+        packageManager ??= contents.packageManager.match(/\w+/u)?.[0] ?? packageManager;
+      }
+    }
+  }
+  packageManager ??= "npm";
+  return packageManager;
+}
+export {
+  asyncRetrievePackageJson,
+  detectPackageManager,
+  fetchPackageLocation,
+  retrievePackageJson
+};

package/dist/path.d.ts

@@ -0,0 +1,40 @@
+import { posix } from 'path';
+/**
+ * Determines if the current environment is POSIX (e.g., macOS, Linux) or not.
+ * 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;
+/**
+ * Converts a Windows-style path to a POSIX-style path.
+ */
+export declare const toPosixPathSeparators: (relativePath: string) => string;
+/**
+ * Normalizes the path separators for the current runtime environment.
+ * On POSIX systems, this function returns the path unchanged.
+ * On Windows systems, it converts all `\` separators to `/`.
+ */
+export declare const normalizePath: (relativePath: string) => string;
+/**
+ * Converts a POSIX-style path to a Windows-style path.
+ * 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;
+/**
+ * Like `process.cwd()`, but always returns a POSIX-style path
+ * (with `/` as separator).
+ */
+export declare const getCwd: () => string;
+/**
+ * A wrapper for Node.js's `path` module that always uses POSIX-style paths
+ * (with `/` as separator).
+ */
+export declare const path: typeof posix & {
+    sep: "/";
+};
+export declare const exportsForTests: {
+    toWin32PathSeparators: (relativePath: string) => string;
+};

package/dist/path.js

@@ -0,0 +1,48 @@
+import { sep, posix, win32 } from "path";
+const isPosix = sep === posix.sep;
+const toPosixPathSeparators = (relativePath) => (
+  //#endregion toPosixPathSeparators
+  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 = win32.join(...paths);
+    return toPosixPathSeparators(result);
+  },
+  normalize(path2) {
+    const result = win32.normalize(path2);
+    return toPosixPathSeparators(result);
+  },
+  relative(from, to) {
+    const result = win32.relative(from, to);
+    return toPosixPathSeparators(result);
+  },
+  dirname(path2) {
+    const result = win32.dirname(path2);
+    return toPosixPathSeparators(result);
+  },
+  resolve(...paths) {
+    const result = win32.resolve(...paths);
+    return toPosixPathSeparators(result);
+  },
+  toNamespacedPath(path2) {
+    const result = win32.toNamespacedPath(path2);
+    return toPosixPathSeparators(result);
+  }
+};
+const exportsForTests = { toWin32PathSeparators };
+export {
+  exportsForTests,
+  getCwd,
+  isPosix,
+  normalizePath,
+  path,
+  toPosixPathSeparators,
+  toSystemPathSeparators
+};

package/dist/vite/externalizeDependenciesPlugin.d.ts

@@ -0,0 +1,91 @@
+import { Plugin } from 'vite';
+import { PackageJson } from '../packageJson.ts';
+/**
+ * Options for managing dependencies in a Vite project.
+ */
+export type DependencyManagementOptions = {
+    /**
+     * Force bundle in these dependencies even if they are declared as
+     * dependencies or peerDependencies.
+     *
+     * @example
+     * This is desirable if you wish to control the version of a dependency or
+     * need to post-process the dependency in some way. Usually, you will declare
+     * such as a devDependency, but there is a use case for declaring it as a
+     * dependency instead:
+     *
+     * - If TypeScript types from the bundled in dependencies are referenced in
+     *   the `.d.ts` files of your library, you will need to declare the package
+     *   as a `dependency`, so that it is still installed on the consumer's
+     *   computer so that TypeScript can correctly resolve the types of that
+     *   library.
+     */
+    readonly bundleIn?: (RegExp | string)[];
+    /**
+     * Force externalize these dependencies, even if they are declared as
+     * devDependencies.
+     *
+     * @example
+     * This is desirable if you are sure the end user will have these dependencies
+     * available, yet do not wish to declare these as devDependencies for some
+     * technical reasons.
+     */
+    readonly externalize?: (RegExp | string)[];
+    /**
+     * By default, this plugin errors if any devDependency is used in runtime code
+     * to avoid bundling in dependencies in a library. In application packages,
+     * bundling in everything is desirable, so enable this option.
+     *
+     * @default false
+     */
+    readonly isApplication?: boolean;
+};
+/**
+ * By default, Rollup will bundle-in all dependencies.
+ *
+ * We change it as follows:
+ * Externalize all packages that are defined as
+ * "dependency" or "peerDependency" in the package.json.
+ * If you wish to bundle-in some package, define it as a "devDependency".
+ *
+ * Bundling-in packages is not recommended because:
+ * - it makes our build take longer
+ * - it pushes larger packages to NPM
+ * - user of our library is locked into the version of the package we bundled in
+ * - if user has two packages using the same library, there will be two copies
+ *   served on the page
+ * - It may break some libraries/prevent them from optimizing correctly
+ *   depending on the production/development mode, or prevent them from loading
+ *   correct code depending on browser/node.js environment.
+ *
+ *   For example, see this statement from Lit:
+ *   https://lit.dev/docs/ssr/authoring/#:~:text=Don%27t%20bundle%20Lit,based%20on%20environment.
+ *
+ * @see {@link ./buildCdn.ts} for CDN dependency bundling details
+ *
+ * @remarks
+ * If a dependency is both a peerDependency and a devDependency, it will still
+ * be externalized (because all peerDependencies are externalized).
+ */
+export declare function externalizeDependencies(options: DependencyManagementOptions): Plugin;
+interface PluginShape extends Plugin {
+    resolveId: {
+        filter: {
+            id: {
+                include: RegExp[];
+                exclude: RegExp[] | undefined;
+            };
+        };
+        handler: (id: string, importer: string | undefined, options: {
+            isEntry: boolean;
+        }) => false | undefined;
+    };
+}
+declare function externalizeDependenciesImplementation(options: DependencyManagementOptions, packageJson: PackageJson): PluginShape;
+declare function matchesAny(id: string, patterns: readonly RegExp[]): boolean;
+export declare const exportsForTests: {
+    stringToStartsWithGlob: (option: RegExp | string) => RegExp;
+    externalizeDependenciesImplementation: typeof externalizeDependenciesImplementation;
+    matchesAny: typeof matchesAny;
+};
+export {};

package/dist/vite/externalizeDependenciesPlugin.js

@@ -0,0 +1,104 @@
+import { builtinModules } from "node:module";
+import { styleText } from "node:util";
+import { toPosixPathSeparators } from "../path.js";
+import { retrievePackageJson } from "../packageJson.js";
+function externalizeDependencies(options) {
+  return externalizeDependenciesImplementation(options, retrievePackageJson());
+}
+function externalizeDependenciesImplementation(options, packageJson) {
+  const externalDependencies = Object.keys({
+    ...packageJson.dependencies,
+    ...packageJson.peerDependencies,
+    ...packageJson.optionalDependencies
+  });
+  const isStrictBundling = toPosixPathSeparators(import.meta.dirname).includes("support-packages/node-toolkit");
+  const bundleIn = options.bundleIn?.map(stringToStartsWithGlob);
+  const explicitExternalize = options.externalize?.map(stringToStartsWithGlob) ?? [];
+  const externalize = [
+    ...explicitExternalize,
+    // BUG: we shouldn't silently externalize node in browser packages.
+    // Consider erroring instead
+    /^node:/u,
+    new RegExp(
+      `^(?:${externalDependencies.join("|")}${externalDependencies.length === 0 ? "" : "|"}${builtinModules.join("|")})(?:/|$)`,
+      "u"
+    )
+  ];
+  const plugin = {
+    name: pluginName,
+    apply: "build",
+    // Externalize before Vite's default resolution runs
+    enforce: "pre",
+    // Rolldown also has "external" option, which can be provided regexes.
+    // Theoretically that would be more efficient due to less communication
+    // overhead, but in practice they always evaluate it on the JS side:
+    // https://github.com/rolldown/rolldown/blob/4f996e637732a26ca04972975884abad5183292b/packages/rolldown/src/utils/bindingify-input-options.ts#L167
+    // https://github.com/rolldown/rolldown/blob/4f996e637732a26ca04972975884abad5183292b/crates/rolldown_binding/src/utils/normalize_binding_options.rs#L130
+    resolveId: {
+      filter: {
+        id: {
+          include: [
+            // In most cases, we want all dependencies in library packages to be
+            // externalized. Thus, this regex matches all non-relative imports.
+            nonRelativeSpecifierPattern,
+            // Also include explicitExternalize because those may target relative
+            // paths (e.g. ./draconvert.js in mock-services).
+            ...explicitExternalize
+          ],
+          exclude: bundleIn
+        }
+      },
+      handler(id, importer, resolveOptions) {
+        if (matchesAny(id, externalize)) {
+          return false;
+        }
+        if (
+          // Entrypoints look like src/components/button/button.tsx, so are
+          // matched by the nonRelativeSpecifierPattern
+          resolveOptions.isEntry || // Virtual specifiers are handled by plugins
+          id.startsWith("\0") || // data: node: virtual:
+          id.includes(":") || // ?raw ?url ?worker - resolved by other plugins
+          id.includes("?") || // Applications can bundle in anything
+          options.isApplication === true
+        ) {
+          return;
+        }
+        const error = `[${pluginName}] Vite tried to bundle in "${id}" (imported by ${importer}).
+This is likely undesirable. To externalize it, declare this dependency as a "dependency", "peerDependency" or "optionalDependency" in package.json.
+If this is intentional, add it to the build.dependencies.bundleIn option in useLumina() or bundleIn option in the vitePresetPlugin().
+If this is an application rather than a library, pass isApplication:true in vitePresetPlugin().`;
+        if (isStrictBundling) {
+          throw Error(error);
+        } else {
+          console.error(styleText("red", `${error}
+This will be an error in future version.`));
+          return;
+        }
+      }
+    }
+  };
+  return plugin;
+}
+const pluginName = "@arcgis/node-toolkit:externalize-dependencies";
+const stringToStartsWithGlob = (option) => typeof option === "string" ? new RegExp(
+  `^${option.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&")}${option.endsWith("/") ? "(?:.+)?" : "(?:/.+)?"}$`,
+  "u"
+) : option;
+const nonRelativeSpecifierPattern = /^[^\.\/]/u;
+function matchesAny(id, patterns) {
+  for (let index = 0; index < patterns.length; ++index) {
+    if (patterns[index].test(id)) {
+      return true;
+    }
+  }
+  return false;
+}
+const exportsForTests = {
+  stringToStartsWithGlob,
+  externalizeDependenciesImplementation,
+  matchesAny
+};
+export {
+  exportsForTests,
+  externalizeDependencies
+};

package/dist/vite/presetPlugin.d.ts

@@ -0,0 +1,13 @@
+import { Plugin } from 'vite';
+import { default as dts } from 'vite-plugin-dts';
+import { DependencyManagementOptions } from './externalizeDependenciesPlugin.ts';
+export type VitePresetOptions = DependencyManagementOptions & {
+    /** Options for `vite-plugin-dts` */
+    dtsOptions?: Parameters<typeof dts>[0] | false;
+};
+/**
+ * Vite preset for all our support packages:
+ * - externalizes all non-dev-dependencies
+ * - generates type declarations (using `vite-plugin-dts`)
+ */
+export declare function vitePresetPlugin({ dtsOptions, externalize, bundleIn, isApplication }?: VitePresetOptions): [Plugin, Plugin, Promise<Plugin> | undefined];

package/dist/vite/presetPlugin.js

@@ -0,0 +1,76 @@
+import { path } from "../path.js";
+import { externalizeDependencies } from "./externalizeDependenciesPlugin.js";
+function shouldSkip(id) {
+  return id.includes("__test") || id.includes(".e2e.") || id.includes(".spec.") || id.includes(".test.") || id.includes(".stories.");
+}
+function vitePresetPlugin({ dtsOptions = {}, externalize, bundleIn, isApplication } = {
+  externalize: [],
+  dtsOptions: {}
+}) {
+  const dist = `${path.resolve("dist")}/`;
+  const distSrc = `${dist}src/`;
+  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 ?? "es2024"
+          },
+          define: env.mode === "test" ? {
+            "process.env.ESRI_INTERNAL": true
+          } : void 0
+        };
+      }
+    },
+    externalizeDependencies({
+      externalize,
+      bundleIn,
+      isApplication
+    }),
+    // This dependency pulls in many others. Since components-build-utils has a
+    // single entry point, we load a large module tree needlessly. To avoid,
+    // load the plugin on demand.
+    dtsOptions === false ? void 0 : import("vite-plugin-dts").then(
+      ({ default: dts }) => dts({
+        logLevel: "warn",
+        ...dtsOptions,
+        compilerOptions: {
+          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 filePathRelativeToDist = `${dist}${filePath.slice(distSrc.length)}`;
+            return dtsOptions?.beforeWriteFile ? await dtsOptions.beforeWriteFile(filePathRelativeToDist, content) : { filePath: filePathRelativeToDist, 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);
+        }
+      })
+    )
+  ];
+}
+export {
+  vitePresetPlugin
+};

package/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "@arcgis/node-toolkit",
+  "version": "5.2.0-next.31",
+  "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",
+  "exports": {
+    "./file": "./dist/file.js",
+    "./glob": "./dist/glob.js",
+    "./path": "./dist/path.js",
+    "./packageJson": "./dist/packageJson.js",
+    "./vite/presetPlugin": "./dist/vite/presetPlugin.js",
+    "./vite/externalizeDependenciesPlugin": "./dist/vite/externalizeDependenciesPlugin.js",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist/"
+  ],
+  "license": "SEE LICENSE IN LICENSE.md",
+  "dependencies": {
+    "@types/node": "~24.11.2",
+    "tslib": "^2.8.1",
+    "vite": "^7.3.2",
+    "vite-plugin-dts": "^4.5.4"
+  }
+}