@arcgis/components-build-utils 4.31.0-next.112

package/LICENSE.md

@@ -0,0 +1,13 @@
+# Licensing
+
+COPYRIGHT © 2024 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), 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.
+
+See use restrictions at http://www.esri.com/legal/pdfs/mla_e204_e300/english
+
+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: contracts@esri.com

package/README.md

@@ -0,0 +1,21 @@
+# ArcGIS Maps SDK for JavaScript - Components Build Utilities
+
+**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
+
+COPYRIGHT © 2024 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), 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.
+
+See use restrictions at <http://www.esri.com/legal/pdfs/mla_e204_e300/english>
+
+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: contracts@esri.com

package/dist/index.cjs

@@ -0,0 +1,223 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+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))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  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,
+  isPosix: () => isPosix,
+  path: () => path,
+  retrievePackageJson: () => retrievePackageJson,
+  sh: () => sh,
+  toPosixPathSeparators: () => toPosixPathSeparators,
+  toSystemPathSeparators: () => toSystemPathSeparators
+});
+module.exports = __toCommonJS(src_exports);
+var import_node_fs3 = require("fs");
+var import_node_path = require("path");
+
+// 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();
+async function createFileIfNotExists(filePath, content) {
+  await (0, import_promises.mkdir)((0, import_path.dirname)(filePath), { recursive: true });
+  if (!await existsAsync(filePath)) {
+    await (0, import_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);
+  while (parentPath.length > 2) {
+    const fullPath = (0, import_path.join)(
+      ...import_path.sep === "/" ? ["/"] : [],
+      ...parentPath,
+      target
+    );
+    if ((0, import_node_fs.existsSync)(fullPath)) {
+      return fullPath;
+    }
+    parentPath.pop();
+  }
+  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);
+  while (parentPath.length > 2) {
+    const fullPath = (0, import_path.join)(
+      ...import_path.sep === "/" ? ["/"] : [],
+      ...parentPath,
+      target
+    );
+    if (await existsAsync(fullPath)) {
+      return fullPath;
+    }
+    parentPath.pop();
+  }
+  return void 0;
+}
+
+// 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 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,
+  join(...paths) {
+    const result = import_win32.default.join(...paths);
+    return toPosixPathSeparators(result);
+  },
+  normalize(path2) {
+    const result = import_win32.default.normalize(path2);
+    return toPosixPathSeparators(result);
+  },
+  relative(from, to) {
+    const result = import_win32.default.relative(from, to);
+    return toPosixPathSeparators(result);
+  },
+  dirname(path2) {
+    const result = import_win32.default.dirname(path2);
+    return toPosixPathSeparators(result);
+  },
+  resolve(...paths) {
+    const result = import_win32.default.resolve(...paths);
+    return toPosixPathSeparators(result);
+  },
+  toNamespacedPath(path2) {
+    const result = import_win32.default.toNamespacedPath(path2);
+    return toPosixPathSeparators(result);
+  }
+};
+var exportsForTests = { toWin32PathSeparators };
+
+// src/packageJson.ts
+var import_node_fs2 = require("fs");
+var import_promises2 = require("fs/promises");
+var cachedPackageJson = {};
+var cachedPackageJsonPromises = {};
+var 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"));
+  return cachedPackageJson[packageJsonPath];
+}
+async function asyncRetrievePackageJson(location = getCwd()) {
+  const packageJsonPath = path.resolve(location, "package.json");
+  if (packageJsonPath in cachedPackageJson) {
+    return cachedPackageJson[packageJsonPath];
+  }
+  cachedPackageJsonPromises[packageJsonPath] ??= asyncReadPackageJson(packageJsonPath);
+  const result = await cachedPackageJsonPromises[packageJsonPath];
+  cachedPackageJson[packageJsonPath] ??= result;
+  return result;
+}
+var asyncReadPackageJson = async (location) => JSON.parse(await (0, import_promises2.readFile)(location, "utf-8"));
+var cachedPackageLocation = {};
+var 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 new Error(
+        `@arcgis/lumina-compiler: 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];
+}
+
+// src/index.ts
+function detectPackageManager(cwd = process.cwd()) {
+  let packageManager = void 0;
+  {
+    const pathParts = cwd.split(import_node_path.sep);
+    while (pathParts.length > 1) {
+      const packageJson = (0, import_node_path.join)(pathParts.join(import_node_path.sep), "package.json");
+      pathParts.pop();
+      if (!(0, import_node_fs3.existsSync)(packageJson)) {
+        continue;
+      }
+      const contents = JSON.parse((0, import_node_fs3.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;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  asyncFindPath,
+  asyncRetrievePackageJson,
+  createFileIfNotExists,
+  detectPackageManager,
+  existsAsync,
+  exportsForTests,
+  fetchPackageLocation,
+  findPath,
+  getCwd,
+  isPosix,
+  path,
+  retrievePackageJson,
+  sh,
+  toPosixPathSeparators,
+  toSystemPathSeparators
+});

package/dist/index.d.cts

@@ -0,0 +1,69 @@
+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>;
+
+/**
+ * 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;
+/**
+ * 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>;
+    "devDependencies"?: Record<string, string>;
+    "peerDependencies"?: Record<string, string>;
+    "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, isPosix, path, retrievePackageJson, sh, toPosixPathSeparators, toSystemPathSeparators };

package/dist/index.d.ts

@@ -0,0 +1,69 @@
+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>;
+
+/**
+ * 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;
+/**
+ * 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>;
+    "devDependencies"?: Record<string, string>;
+    "peerDependencies"?: Record<string, string>;
+    "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, isPosix, path, retrievePackageJson, sh, toPosixPathSeparators, toSystemPathSeparators };

package/dist/index.js

@@ -0,0 +1,174 @@
+// src/index.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "node:fs";
+import { join as join2, sep as sep3 } from "node:path";
+
+// src/file.ts
+import { existsSync } from "node:fs";
+import { access, constants, mkdir, writeFile } from "node:fs/promises";
+import { execSync } from "node:child_process";
+import { dirname, join, resolve, sep } from "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();
+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 > 2) {
+    const fullPath = join(
+      ...sep === "/" ? ["/"] : [],
+      ...parentPath,
+      target
+    );
+    if (existsSync(fullPath)) {
+      return fullPath;
+    }
+    parentPath.pop();
+  }
+  return void 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 > 2) {
+    const fullPath = join(
+      ...sep === "/" ? ["/"] : [],
+      ...parentPath,
+      target
+    );
+    if (await existsAsync(fullPath)) {
+      return fullPath;
+    }
+    parentPath.pop();
+  }
+  return void 0;
+}
+
+// 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 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 : {
+  ...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);
+  }
+};
+var exportsForTests = { toWin32PathSeparators };
+
+// src/packageJson.ts
+import { readFileSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+var cachedPackageJson = {};
+var cachedPackageJsonPromises = {};
+var rootPackageJsonLocation;
+function retrievePackageJson(location) {
+  const packageJsonPath = location ? path.resolve(location, "package.json") : rootPackageJsonLocation ??= findPath("package.json");
+  cachedPackageJson[packageJsonPath] ??= JSON.parse(readFileSync(packageJsonPath, "utf-8"));
+  return cachedPackageJson[packageJsonPath];
+}
+async function asyncRetrievePackageJson(location = getCwd()) {
+  const packageJsonPath = path.resolve(location, "package.json");
+  if (packageJsonPath in cachedPackageJson) {
+    return cachedPackageJson[packageJsonPath];
+  }
+  cachedPackageJsonPromises[packageJsonPath] ??= asyncReadPackageJson(packageJsonPath);
+  const result = await cachedPackageJsonPromises[packageJsonPath];
+  cachedPackageJson[packageJsonPath] ??= result;
+  return result;
+}
+var asyncReadPackageJson = async (location) => JSON.parse(await readFile(location, "utf-8"));
+var cachedPackageLocation = {};
+var 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 new Error(
+        `@arcgis/lumina-compiler: 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];
+}
+
+// src/index.ts
+function detectPackageManager(cwd = process.cwd()) {
+  let packageManager = void 0;
+  {
+    const pathParts = cwd.split(sep3);
+    while (pathParts.length > 1) {
+      const packageJson = join2(pathParts.join(sep3), "package.json");
+      pathParts.pop();
+      if (!existsSync2(packageJson)) {
+        continue;
+      }
+      const contents = JSON.parse(readFileSync2(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 {
+  asyncFindPath,
+  asyncRetrievePackageJson,
+  createFileIfNotExists,
+  detectPackageManager,
+  existsAsync,
+  exportsForTests,
+  fetchPackageLocation,
+  findPath,
+  getCwd,
+  isPosix,
+  path,
+  retrievePackageJson,
+  sh,
+  toPosixPathSeparators,
+  toSystemPathSeparators
+};

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "@arcgis/components-build-utils",
+  "version": "4.31.0-next.112",
+  "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",
+  "main": "dist/index.cjs",
+  "module": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "files": [
+    "dist/"
+  ],
+  "bin": {
+    "awc": "src/commands/run-wrapper.js"
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/",
+    "access": "public"
+  },
+  "license": "SEE LICENSE IN LICENSE.md",
+  "scripts": {
+    "build": "tsup --silent",
+    "build:dev": "tsup --silent --sourcemap",
+    "watch": "yarn build:dev --watch --onSuccess 'yarn'",
+    "test": "vitest",
+    "test:watch": "vitest --watch",
+    "coverage": "vitest run --coverage",
+    "lint-test": "vitest related --run --passWithNoTests",
+    "clean": "rimraf ./dist ./turbo ./node_modules"
+  },
+  "dependencies": {
+    "tslib": "^2.7.0"
+  },
+  "devDependencies": {
+    "@arcgis/typescript-config": "4.31.0-next.112",
+    "@commander-js/extra-typings": "^11.1.0",
+    "commander": "^11.1.0",
+    "eslint": "^8.55.0",
+    "rimraf": "^5.0.0",
+    "tsup": "^8.2.4",
+    "typescript": "~5.4.0",
+    "vitest": "^2.1.1"
+  },
+  "gitHead": "388967aea3e36323fae8a2a117cb9c67e6197a66"
+}

package/src/commands/run-wrapper.js

@@ -0,0 +1,17 @@
+#!/usr/bin/env node
+import { spawn } from "node:child_process";
+import { join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const scriptPath = join(fileURLToPath(import.meta.url), "..", "run.ts");
+const commandArguments = process.argv.slice(2);
+
+const child = spawn("npx", ["tsx", scriptPath, ...commandArguments], {
+  stdio: "inherit",
+  shell: true,
+});
+
+// Forward the exit code
+child.on("exit", function (code) {
+  process.exit(code);
+});