@arcgis/components-build-utils 5.2.0-next.30 → 5.2.0-next.32

package/README.md

@@ -4,8 +4,6 @@
 
 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.

package/dist/index.d.ts

@@ -1,5 +1,51 @@
-export { existsAsync, sh, sp, asyncSh, createFileIfNotExists, findPath, asyncFindPath } from './file.ts';
-export { gitIgnoreFileToGlobs, gitIgnoreToGlob } from './glob.ts';
-export { isPosix, toPosixPathSeparators, normalizePath, toSystemPathSeparators, getCwd, path } from './path.ts';
-export { type PackageJson, retrievePackageJson, asyncRetrievePackageJson, fetchPackageLocation, detectPackageManager, } from './packageJson.ts';
-export { vitePresetPlugin, type DependencyManagementOptions, externalizeDependencies } from './vite.ts';
+import { sh as shAliased, sp as spAliased, asyncSh as asyncShAliased, findPath as findPathAliased, asyncFindPath as asyncFindPathAliased } from '@arcgis/node-toolkit/file';
+import { gitIgnoreFileToGlobs as gitIgnoreFileToGlobsAliased } from '@arcgis/node-toolkit/glob';
+import { retrievePackageJson as retrievePackageJsonAliased, asyncRetrievePackageJson as asyncRetrievePackageJsonAliased, fetchPackageLocation as fetchPackageLocationAliased, detectPackageManager as detectPackageManagerAliased, PackageJson as PackageJsonAliased } from '@arcgis/node-toolkit/packageJson';
+import { vitePresetPlugin as vitePresetPluginAliased } from '@arcgis/node-toolkit/vite/presetPlugin';
+import { DependencyManagementOptions as DependencyManagementOptionsAliased, externalizeDependencies as externalizeDependenciesAliased } from '@arcgis/node-toolkit/vite/externalizeDependenciesPlugin';
+/** @deprecated import { existsAsync } from "@arcgis/node-toolkit/file"; instead */
+export declare const existsAsync: (file: string) => Promise<boolean>;
+/** @deprecated import { sh } from "@arcgis/node-toolkit/file"; instead */
+export declare const sh: typeof shAliased;
+/** @deprecated import { sp } from "@arcgis/node-toolkit/file"; instead */
+export declare const sp: typeof spAliased;
+/** @deprecated import { asyncSh } from "@arcgis/node-toolkit/file"; instead */
+export declare const asyncSh: typeof asyncShAliased;
+/** @deprecated import { findPath } from "@arcgis/node-toolkit/file"; instead */
+export declare const findPath: typeof findPathAliased;
+/** @deprecated import { asyncFindPath } from "@arcgis/node-toolkit/file"; instead */
+export declare const asyncFindPath: typeof asyncFindPathAliased;
+/** @deprecated import { gitIgnoreFileToGlobs } from "@arcgis/node-toolkit/glob"; instead */
+export declare const gitIgnoreFileToGlobs: typeof gitIgnoreFileToGlobsAliased;
+/** @deprecated import { gitIgnoreToGlob } from "@arcgis/node-toolkit/glob"; instead */
+export declare const gitIgnoreToGlob: (pattern: string) => string;
+/** @deprecated import { isPosix } from "@arcgis/node-toolkit/path"; instead */
+export declare const isPosix: boolean;
+/** @deprecated import { toPosixPathSeparators } from "@arcgis/node-toolkit/path"; instead */
+export declare const toPosixPathSeparators: (relativePath: string) => string;
+/** @deprecated import { normalizePath } from "@arcgis/node-toolkit/path"; instead */
+export declare const normalizePath: (relativePath: string) => string;
+/** @deprecated import { toSystemPathSeparators } from "@arcgis/node-toolkit/path"; instead */
+export declare const toSystemPathSeparators: (relativePath: string) => string;
+/** @deprecated import { getCwd } from "@arcgis/node-toolkit/path"; instead */
+export declare const getCwd: () => string;
+/** @deprecated import { path } from "@arcgis/node-toolkit/path"; instead */
+export declare const path: import('path').PlatformPath & {
+    sep: "/";
+};
+/** @deprecated import type { PackageJson } from "@arcgis/node-toolkit/packageJson"; instead */
+export type PackageJson = PackageJsonAliased;
+/** @deprecated import { retrievePackageJson } from "@arcgis/node-toolkit/packageJson"; instead */
+export declare const retrievePackageJson: typeof retrievePackageJsonAliased;
+/** @deprecated import { asyncRetrievePackageJson } from "@arcgis/node-toolkit/packageJson"; instead */
+export declare const asyncRetrievePackageJson: typeof asyncRetrievePackageJsonAliased;
+/** @deprecated import { fetchPackageLocation } from "@arcgis/node-toolkit/packageJson"; instead */
+export declare const fetchPackageLocation: typeof fetchPackageLocationAliased;
+/** @deprecated import { detectPackageManager } from "@arcgis/node-toolkit/packageJson"; instead */
+export declare const detectPackageManager: typeof detectPackageManagerAliased;
+/** @deprecated import type { DependencyManagementOptions } from "@arcgis/node-toolkit/vite/externalizeDependenciesPlugin"; instead */
+export type DependencyManagementOptions = DependencyManagementOptionsAliased;
+/** @deprecated import { vitePresetPlugin } from "@arcgis/node-toolkit/vite/presetPlugin"; instead */
+export declare const vitePresetPlugin: typeof vitePresetPluginAliased;
+/** @deprecated import { externalizeDependencies } from "@arcgis/node-toolkit/vite/externalizeDependenciesPlugin"; instead */
+export declare const externalizeDependencies: typeof externalizeDependenciesAliased;

package/dist/index.js

@@ -1,409 +1,33 @@
-import { access, existsSync, readFileSync } from "node:fs";
-import { constants, mkdir, writeFile, readFile } from "node:fs/promises";
-import { dirname, resolve, sep, join, posix, win32 } from "path";
-import { fileURLToPath } from "node:url";
-import { execSync, spawnSync, exec } from "node:child_process";
-import { styleText } from "node:util";
-import { builtinModules } from "node:module";
-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)))
-);
-function sh(command, options = {}) {
-  try {
-    const normalizedOptions = { encoding: "utf8", ...options };
-    return execSync(command.trim(), normalizedOptions).trim();
-  } catch (error) {
-    makeExecErrorReadable(error);
-    throw error;
-  }
-}
-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;
-}
-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 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 findPath(target, startDirectory = process.cwd()) {
-  const resolvedStartDirectory = startDirectory.startsWith("file:///") ? dirname(fileURLToPath(startDirectory)) : resolve(startDirectory);
-  const parentPath = resolvedStartDirectory.split(sep);
-  while (parentPath.length > searchStopIndex) {
-    const fullPath = join(
-      ...sep === "/" ? ["/"] : [],
-      ...parentPath,
-      target
-    );
-    if (existsSync(fullPath)) {
-      return fullPath;
-    }
-    parentPath.pop();
-  }
-  return void 0;
-}
-const searchStopIndex = 0;
-async function asyncFindPath(target, startDirectory = process.cwd()) {
-  const resolvedStartDirectory = startDirectory.startsWith("file:///") ? dirname(fileURLToPath(startDirectory)) : resolve(startDirectory);
-  const parentPath = resolvedStartDirectory.split(sep);
-  while (parentPath.length > searchStopIndex) {
-    const fullPath = join(
-      ...sep === "/" ? ["/"] : [],
-      ...parentPath,
-      target
-    );
-    if (await existsAsync(fullPath)) {
-      return fullPath;
-    }
-    parentPath.pop();
-  }
-  return void 0;
-}
-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}/**`;
-}
-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) {
-    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 cachedPackageJson = {};
-const cachedPackageJsonPromises = {};
-let rootPackageJsonLocation;
-function retrievePackageJson(location, cache = true) {
-  const packageJsonPath = location ? path.resolve(location, "package.json") : rootPackageJsonLocation ??= findPath("package.json");
-  if (cache) {
-    cachedPackageJson[packageJsonPath] ??= JSON.parse(readFileSync(packageJsonPath, "utf-8"));
-    return cachedPackageJson[packageJsonPath];
-  }
-  return JSON.parse(readFileSync(packageJsonPath, "utf-8"));
-}
-async function asyncRetrievePackageJson(location) {
-  const packageJsonPath = location ? path.resolve(location, "package.json") : rootPackageJsonLocation ??= findPath("package.json");
-  if (packageJsonPath in cachedPackageJson) {
-    return cachedPackageJson[packageJsonPath];
-  }
-  cachedPackageJsonPromises[packageJsonPath] ??= asyncReadPackageJson(packageJsonPath);
-  const result = await cachedPackageJsonPromises[packageJsonPath];
-  cachedPackageJson[packageJsonPath] ??= result;
-  return result;
-}
-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/components-build-utils: 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;
-}
-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 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.");
-}
-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/components-build-utils"
-  );
-  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/components-build-utils: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;
-}
+import { asyncFindPath as asyncFindPath$1, asyncSh as asyncSh$1, existsAsync as existsAsync$1, findPath as findPath$1, sh as sh$1, sp as sp$1 } from "@arcgis/node-toolkit/file";
+import { gitIgnoreFileToGlobs as gitIgnoreFileToGlobs$1, gitIgnoreToGlob as gitIgnoreToGlob$1 } from "@arcgis/node-toolkit/glob";
+import { getCwd as getCwd$1, isPosix as isPosix$1, normalizePath as normalizePath$1, path as path$1, toPosixPathSeparators as toPosixPathSeparators$1, toSystemPathSeparators as toSystemPathSeparators$1 } from "@arcgis/node-toolkit/path";
+import { asyncRetrievePackageJson as asyncRetrievePackageJson$1, detectPackageManager as detectPackageManager$1, fetchPackageLocation as fetchPackageLocation$1, retrievePackageJson as retrievePackageJson$1 } from "@arcgis/node-toolkit/packageJson";
+import { vitePresetPlugin as vitePresetPlugin$1 } from "@arcgis/node-toolkit/vite/presetPlugin";
+import { externalizeDependencies as externalizeDependencies$1 } from "@arcgis/node-toolkit/vite/externalizeDependenciesPlugin";
+const existsAsync = existsAsync$1;
+const sh = sh$1;
+const sp = sp$1;
+const asyncSh = asyncSh$1;
+const findPath = findPath$1;
+const asyncFindPath = asyncFindPath$1;
+const gitIgnoreFileToGlobs = gitIgnoreFileToGlobs$1;
+const gitIgnoreToGlob = gitIgnoreToGlob$1;
+const isPosix = isPosix$1;
+const toPosixPathSeparators = toPosixPathSeparators$1;
+const normalizePath = normalizePath$1;
+const toSystemPathSeparators = toSystemPathSeparators$1;
+const getCwd = getCwd$1;
+const path = path$1;
+const retrievePackageJson = retrievePackageJson$1;
+const asyncRetrievePackageJson = asyncRetrievePackageJson$1;
+const fetchPackageLocation = fetchPackageLocation$1;
+const detectPackageManager = detectPackageManager$1;
+const vitePresetPlugin = vitePresetPlugin$1;
+const externalizeDependencies = externalizeDependencies$1;
 export {
   asyncFindPath,
   asyncRetrievePackageJson,
   asyncSh,
-  createFileIfNotExists,
   detectPackageManager,
   existsAsync,
   externalizeDependencies,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arcgis/components-build-utils",
-  "version": "5.2.0-next.30",
+  "version": "5.2.0-next.32",
   "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",
@@ -8,16 +8,17 @@
   "module": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "exports": {
-    ".": "./dist/index.js"
+    ".": "./dist/index.js",
+    "./package.json": "./package.json"
   },
   "files": [
     "dist/"
   ],
   "license": "SEE LICENSE IN LICENSE.md",
   "dependencies": {
-    "@types/node": "^24.10.0",
+    "@types/node": "~24.11.2",
     "tslib": "^2.8.1",
     "vite": "^7.3.2",
-    "vite-plugin-dts": "^4.5.4"
+    "@arcgis/node-toolkit": "5.2.0-next.32"
   }
 }

package/dist/file.d.ts

@@ -1,18 +0,0 @@
-import { ExecSyncOptionsWithStringEncoding, SpawnSyncOptionsWithStringEncoding } from 'node:child_process';
-export declare const existsAsync: (file: string) => Promise<boolean>;
-/** Wrapper for execSync to execute shell commands */
-export declare function sh(command: string, options?: Partial<ExecSyncOptionsWithStringEncoding>): string;
-/** Wrapper for spawnSync to execute commands without shell interpolation. */
-export declare function sp(command: string, args: string[], options?: Partial<SpawnSyncOptionsWithStringEncoding>): string;
-export declare function asyncSh(command: string, options?: Partial<ExecSyncOptionsWithStringEncoding>): Promise<string>;
-export 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
- */
-export 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
- */
-export declare function asyncFindPath(target: string, startDirectory?: string): Promise<string | undefined>;

package/dist/glob.d.ts

@@ -1,24 +0,0 @@
-/**
- * Read `.gitignore` files and convert it to globs that are accepted by ESLint
- *
- * @example
- * ```ts
- * // eslint.config.js
- * import { gitIgnoreFileToGlobs } from "@arcgis/components-build-utils";
- * 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/components-build-utils"
- * instead
- */
-export declare const gitIgnoreToGlob: (pattern: string) => string;

package/dist/packageJson.d.ts

@@ -1,50 +0,0 @@
-/**
- * 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 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>;
-    "scripts"?: Record<string, string>;
-    "packageManager"?: string;
-};
-export declare function retrievePackageJson(location?: string, cache?: boolean): PackageJson;
-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/path.d.ts

@@ -1,30 +0,0 @@
-import { posix } from 'path';
-/**
- * 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;
-/**
- * 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/vite.d.ts

@@ -1,101 +0,0 @@
-import { Plugin } from 'vite';
-import { default as dts } from 'vite-plugin-dts';
-import { PackageJson } from './packageJson.ts';
-/**
- * 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, }?: DependencyManagementOptions & {
-    /** Additional options for `vite-plugin-dts` */
-    dtsOptions?: Parameters<typeof dts>[0] | false;
-}): [Plugin, Plugin, Promise<Plugin> | undefined];
-/**
- * Options for externalizing dependencies.
- */
-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 {};