@arcgis/node-toolkit 5.2.0-next.129 → 5.2.0-next.131

package/dist/codeowners.d.ts

@@ -0,0 +1,35 @@
+/**
+ * A pattern and its owners from a CODEOWNERS file.
+ *
+ * @public
+ */
+export interface CodeownersEntry {
+    pattern: string;
+    owners: string[];
+}
+/**
+ * Resolves ownership using directory patterns, globs, and last-match precedence.
+ *
+ * @public
+ */
+export interface Codeowners {
+    getOwners: (fileName: string) => string[];
+}
+/**
+ * Reads a CODEOWNERS file and returns its entries.
+ * Defaults to `.github/CODEOWNERS` in the nearest Git repository found from
+ * the current working directory. Throws if the repository or file is missing.
+ *
+ * @public
+ * @param codeownersPath Optional explicit path to a CODEOWNERS file.
+ */
+export declare function readCodeownersEntries(codeownersPath?: string | undefined): CodeownersEntry[];
+/**
+ * Loads `.github/CODEOWNERS` from the nearest Git repository found from the
+ * current working directory. Returns undefined if the repository or file is missing.
+ * Returned ownership lookups accept file paths relative to the current working
+ * directory or absolute file paths.
+ *
+ * @public
+ */
+export declare function loadCodeowners(): Codeowners | undefined;

package/dist/codeowners.js

@@ -0,0 +1,50 @@
+import { path } from "./path.js";
+import { findPath } from "./file.js";
+import { existsSync, readFileSync } from "node:fs";
+import picomatch from "picomatch";
+function readCodeownersEntries(codeownersPath = findCodeownersPath()) {
+  if (!codeownersPath) {
+    throw new Error(`Unable to find Git repository from current working directory: ${process.cwd()}`);
+  }
+  return parseCodeownersEntries(readFileSync(codeownersPath, "utf8"));
+}
+function loadCodeowners() {
+  const codeownersPath = findCodeownersPath();
+  return codeownersPath && existsSync(codeownersPath) ? createCodeowners(readCodeownersEntries(codeownersPath), path.dirname(path.dirname(codeownersPath))) : void 0;
+}
+function findCodeownersPath() {
+  const gitPath = findPath(".git");
+  return gitPath ? path.join(path.dirname(gitPath), ".github", "CODEOWNERS") : void 0;
+}
+function parseCodeownersEntries(contents) {
+  return contents.split(/\r?\n/u).map((line) => line.trim()).filter((line) => line !== "" && !line.startsWith("#")).map((line) => {
+    const [pattern, ...owners] = line.split(/\s+/u);
+    return { pattern, owners };
+  });
+}
+function createCodeowners(rawEntries, repositoryRoot) {
+  const entries = rawEntries.map(({ pattern, owners }) => {
+    const normalizedPattern = pattern.startsWith("/") ? pattern.slice(1) : pattern;
+    const matcherPattern = normalizedPattern.includes("/") ? normalizedPattern : `**/${normalizedPattern}`;
+    return {
+      matches: picomatch([matcherPattern, `${matcherPattern.replace(/\/$/u, "")}/**`], { dot: true }),
+      owners
+    };
+  });
+  return {
+    getOwners(fileName) {
+      const relativeFileName = path.relative(repositoryRoot, fileName);
+      let owners = [];
+      for (const entry of entries) {
+        if (entry.matches(relativeFileName)) {
+          owners = entry.owners;
+        }
+      }
+      return owners;
+    }
+  };
+}
+export {
+  loadCodeowners,
+  readCodeownersEntries
+};

package/dist/file.js

@@ -1,5 +1,5 @@
 import { access, existsSync } from "node:fs";
-import { constants, mkdir, writeFile } from "node:fs/promises";
+import { mkdir, writeFile, constants } from "node:fs/promises";
 import { dirname, resolve, sep, join } from "path";
 import { fileURLToPath } from "node:url";
 const existsAsync = async (file) => (

package/dist/packageJson.d.ts

@@ -102,3 +102,16 @@ export declare function fetchPackageLocation(packageName: string, cwd?: string):
  * @param packageName
  */
 export declare function findPackageJson(packageName: string): PackageJson | undefined;
+/**
+ * Detect the package manager from the nearest ancestor package.json with a packageManager field.
+ * Defaults to npm when no package manager is declared.
+ * Uses retrievePackageJson's cached manifest reads.
+ * @example
+ * ```ts
+ * const packageManager = detectPackageManager();
+ * console.log(packageManager); // e.g., "npm" or "pnpm"
+ * ```
+ * @public
+ * @param cwd The current working directory to start searching for the package manager from. Defaults to process.cwd().
+ */
+export declare function detectPackageManager(cwd?: string): string;

package/dist/packageJson.js

@@ -1,6 +1,6 @@
 import { readFile } from "node:fs/promises";
 import { path } from "./path.js";
-import { asyncFindPath, findPath } from "./file.js";
+import { findPath, asyncFindPath } from "./file.js";
 import { readFileSync } from "node:fs";
 const cachedPackageJson = {};
 const cachedPackageJsonPromises = {};
@@ -50,8 +50,30 @@ function findPackageJson(packageName) {
   }
   return retrievePackageJson(path2);
 }
+function detectPackageManager(cwd = process.cwd()) {
+  let packageManager = void 0;
+  let directory = path.resolve(cwd);
+  for (; ; ) {
+    const packageJsonPath = findPath("package.json", directory);
+    if (packageJsonPath === void 0) {
+      break;
+    }
+    const packageDirectory = path.dirname(packageJsonPath);
+    const contents = retrievePackageJson(packageDirectory);
+    if (typeof contents === "object" && !Array.isArray(contents) && typeof contents.packageManager === "string") {
+      packageManager ??= contents.packageManager.match(/\w+/u)?.[0] ?? packageManager;
+    }
+    directory = path.dirname(packageDirectory);
+    if (directory === packageDirectory) {
+      break;
+    }
+  }
+  packageManager ??= "npm";
+  return packageManager;
+}
 export {
   asyncRetrievePackageJson,
+  detectPackageManager,
   fetchPackageLocation,
   findPackageJson,
   retrievePackageJson

package/dist/vite/simpleTypesEmit.d.ts

@@ -6,8 +6,8 @@ import type { Plugin } from "vite";
  * Do not use this plugin for new code.
  * Use https://webgis.esri.com/references/api-extractor/integrations instead.
  *
- * This exists only for usage by `@arcgis/toolkit` and
- * `@arcgis/node-toolkit` as they cannot use API Extractor to avoid a
+ * This exists only for usage by `@arcgis/toolkit`,
+ * `@arcgis/node-toolkit`, and `@webgis/monorepo-toolkit` as they cannot use API Extractor to avoid a
  * cyclical dependency.
  *
  * This serves as a minimal replacement for vite-plugin-dts. For comparison,
@@ -15,5 +15,9 @@ import type { Plugin } from "vite";
  * vite-plugin-dts.
  *
  * @public
+ * @param options Declaration emission options.
+ * @param options.mapDeclarationImport Optional mapping for module specifiers in emitted declarations.
  */
-export declare function simpleTypesEmit(): Plugin;
+export declare function simpleTypesEmit({ mapDeclarationImport, }?: {
+    mapDeclarationImport?: (specifier: string) => string;
+}): Plugin;

package/dist/vite/simpleTypesEmit.js

@@ -2,7 +2,9 @@ import ts from "typescript";
 import { loadTypeScriptConfig } from "./typeScript.js";
 import { path } from "../path.js";
 import { mkdir, writeFile } from "node:fs/promises";
-function simpleTypesEmit() {
+function simpleTypesEmit({
+  mapDeclarationImport
+} = {}) {
   let oldProgram;
   let isWatchMode = false;
   const sourcePrefix = path.join(process.cwd(), "src/");
@@ -42,7 +44,8 @@ function simpleTypesEmit() {
               );
             },
             void 0,
-            true
+            true,
+            mapDeclarationImport ? { afterDeclarations: [createDeclarationImportTransformer(mapDeclarationImport)] } : void 0
           );
           allDiagnostics.push(...diagnostics.diagnostics);
         }
@@ -66,6 +69,29 @@ function simpleTypesEmit() {
     }
   };
 }
+function createDeclarationImportTransformer(mapDeclarationImport) {
+  return (context) => {
+    let parent;
+    let importTypeArgument;
+    const visit = (node) => {
+      if (ts.isStringLiteral(node) && parent !== void 0 && (ts.isImportDeclaration(parent) || ts.isExportDeclaration(parent) || ts.isLiteralTypeNode(parent) && parent === importTypeArgument)) {
+        const specifier = mapDeclarationImport(node.text);
+        return specifier === node.text ? node : context.factory.createStringLiteral(specifier);
+      }
+      const previousParent = parent;
+      const previousImportTypeArgument = importTypeArgument;
+      parent = node;
+      if (ts.isImportTypeNode(node)) {
+        importTypeArgument = node.argument;
+      }
+      const result = ts.visitEachChild(node, visit, context);
+      parent = previousParent;
+      importTypeArgument = previousImportTypeArgument;
+      return result;
+    };
+    return (root) => ts.visitNode(root, visit);
+  };
+}
 const isIncludedFile = (filePath, prefix) => isPermittedFile(filePath) && isInIncludedFolder(filePath, prefix);
 const isPermittedFile = (filePath) => (filePath.endsWith(".ts") || filePath.endsWith(".tsx")) && !isTestFile(filePath) && !isStoryFile(filePath);
 const isTestFile = (filePath) => filePath.includes("__test") || filePath.includes(".e2e.") || filePath.includes(".spec.") || filePath.includes(".test.");

package/package.json

@@ -1,10 +1,11 @@
 {
   "name": "@arcgis/node-toolkit",
-  "version": "5.2.0-next.129",
+  "version": "5.2.0-next.131",
   "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": {
+    "./codeowners": "./dist/codeowners.js",
     "./file": "./dist/file.js",
     "./shell": "./dist/shell.js",
     "./glob": "./dist/glob.js",
@@ -15,7 +16,6 @@
     "./vite/installPlaywright": "./dist/vite/installPlaywright.js",
     "./vite/simpleTypesEmit": "./dist/vite/simpleTypesEmit.js",
     "./vite/typeScript": "./dist/vite/typeScript.js",
-    "./workspace": "./dist/workspace.js",
     "./package.json": "./package.json"
   },
   "files": [
@@ -23,9 +23,8 @@
   ],
   "license": "SEE LICENSE IN LICENSE.md",
   "dependencies": {
-    "@pnpm/workspace.read-manifest": "^1000.2.10",
     "@types/node": "~24.11.2",
-    "tinyglobby": "~0.2.17",
+    "picomatch": "^4.0.4",
     "tslib": "^2.8.1",
     "typescript": "~6.0.3",
     "vite": "^7.3.2",

package/dist/workspace.d.ts

@@ -1,97 +0,0 @@
-import { type PackageJson } from "./packageJson.ts";
-/**
- * Set the target file to use when finding the root of the repository.
- * By default, it looks for the pnpm-lock.yaml file, but you can specify a different target file if needed.
- *
- * @internal
- * @param target
- */
-export declare function setRootTargetFile(target: string): void;
-/**
- * Locate the root directory by finding a target file.
- * By default, it looks for the pnpm-lock.yaml file, but you can call setRootTargetFile to specify a different target file if needed.
- *
- * @internal
- */
-export declare function findRepositoryRoot(): string;
-/** @internal */
-export type PackageWalkerItem = {
-    /** @internal */
-    packagePath: string;
-    /** @internal */
-    manifest: PackageJson;
-};
-/**
- * @internal
- * @param item
- */
-type PackageWalkerCallback<T> = (item: PackageWalkerItem) => T;
-/** @internal */
-type WorkspacePackagesWalkerOptions = {
-    /**
-     * Whether to include the root package. By default, it is not included.
-     *
-     * @internal
-     */
-    includeRootPackage?: boolean;
-    /**
-     * The repository root. By default, it is the directory containing pnpm-lock.yaml.
-     *
-     * @internal
-     */
-    repositoryRoot?: string;
-};
-/**
- * Walk all pnpm workspace packages and collect non-null callback results.
- *
- * @internal
- */
-export declare function workspacePackagesWalker<T>(callback: PackageWalkerCallback<T>, { includeRootPackage, repositoryRoot }?: WorkspacePackagesWalkerOptions): Promise<NonNullable<Awaited<T>>[]>;
-/**
- * Get the path to the Turbo CLI. This allows us to directly invoke it without incurring the overhead of going through
- * the package manager.
- *
- * @internal
- * @param repositoryRoot
- */
-export declare function getTurboPath(repositoryRoot?: string): string;
-/**
- * Parse a version string into its components.
- *
- * @internal
- * @param version
- * @example
- * ```ts
- * const parsed = parseVersion("4.34.0-next.123");
- * // { major: 4, minor: 34, patch: 0, prerelease: ["next", 123], majorMinorVersion: "4.34", cdnVersion: "4.34.0-next" }
- * const parsed = parseVersion("5.2.20");
- * // { major: 5, minor: 2, patch: 20, prerelease: [], majorMinorVersion: "5.2", cdnVersion: "5.2.20" }
- * ```
- */
-export declare const parseVersion: (version: string) => {
-    major: string;
-    minor: string;
-    patch: string;
-    prerelease: string[];
-    majorMinorVersion: string;
-    cdnVersion: string;
-};
-/**
- * Get the system version from the root package.json. The system version is the version of the monorepo as a whole, and is used for deployment and publishing.
- * The majorMinorVersion is major.minor version of the system version, and is used for deployment and publishing.
- * The cdnVersion is the system version without any pre-release or build metadata, and is used for deployment and publishing
- * (e.g. 1.2.3-next.4 becomes 1.2.3-next and 5.2.1 stays 5.2.1).
- *
- * @internal
- */
-export declare function getSystemVersion(): ReturnType<typeof parseVersion> & {
-    version: string;
-};
-/**
- * Detect if current repository/monorepo uses npm, pnpm, or yarn
- *
- * @internal
- * @param cwd
- */
-export declare function detectPackageManager(cwd?: string): string;
-export {};

package/dist/workspace.js

@@ -1,128 +0,0 @@
-import { readWorkspaceManifest } from "@pnpm/workspace.read-manifest";
-import { findPath } from "./file.js";
-import { retrievePackageJson, asyncRetrievePackageJson } from "./packageJson.js";
-import { path } from "./path.js";
-import { existsSync, readFileSync } from "node:fs";
-import { styleText } from "node:util";
-import { glob } from "tinyglobby";
-let rootTargetFile = "pnpm-lock.yaml";
-function setRootTargetFile(target) {
-  rootTargetFile = target;
-}
-function findRepositoryRoot() {
-  const lockFilePath = findPath(rootTargetFile);
-  if (!lockFilePath) {
-    throw new Error(
-      `Unable to find root with target "${rootTargetFile}" from current working directory: ${process.cwd()}`
-    );
-  }
-  return path.dirname(lockFilePath);
-}
-async function getWorkspacePackagePaths(includeRootPackage = true, repositoryRoot = findRepositoryRoot()) {
-  const packagePatterns = (await readWorkspaceManifest(repositoryRoot))?.packages ?? [];
-  const packageJsonPatterns = packagePatterns.map((packagePattern) => `${packagePattern}/package.json`);
-  if (includeRootPackage) {
-    packageJsonPatterns.push("package.json");
-  }
-  const packageJsonPaths = await glob(packageJsonPatterns, {
-    dot: true,
-    onlyFiles: true,
-    absolute: false,
-    cwd: repositoryRoot,
-    followSymbolicLinks: false
-  });
-  return packageJsonPaths.map((packageJsonPath) => path.dirname(packageJsonPath));
-}
-async function workspacePackagesWalker(callback, { includeRootPackage = false, repositoryRoot = findRepositoryRoot() } = {}) {
-  const packagePaths = await getWorkspacePackagePaths(includeRootPackage, repositoryRoot);
-  const results = [];
-  try {
-    await Promise.all(
-      packagePaths.map(async (packagePath) => {
-        try {
-          const manifest = await asyncRetrievePackageJson(path.join(repositoryRoot, packagePath));
-          if (!manifest) {
-            console.error(styleText("red", `Failed to read package manifest at ${packagePath}, skipping.`));
-            return;
-          }
-          const output = await callback({ packagePath, manifest }) ?? void 0;
-          if (output !== void 0) {
-            results.push(output);
-          }
-        } catch (error) {
-          console.error(styleText("red", `Error processing package ${packagePath}:`));
-          console.error(error);
-          throw error;
-        }
-      })
-    );
-  } catch (error) {
-    console.error(String(error));
-    const workspaceError = new Error("Error occurred during workspace package walking.");
-    workspaceError.stack = "";
-    throw workspaceError;
-  }
-  return results;
-}
-function getTurboPath(repositoryRoot = findRepositoryRoot()) {
-  return path.join(repositoryRoot, "node_modules/turbo/bin/turbo");
-}
-const parseVersion = (version) => {
-  const versionParts = /^(?<major>0|[1-9]\d*)\.(?<minor>0|[1-9]\d*)\.(?<patch>0|[1-9]\d*)(?:-(?<prereleaseParts>[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/u.exec(
-    version
-  );
-  if (!versionParts?.groups) {
-    throw new Error(`Unable to parse version "${version}"`);
-  }
-  const { major, minor, patch, prereleaseParts } = versionParts.groups;
-  const prerelease = prereleaseParts ? prereleaseParts.split(".") : [];
-  const majorMinorVersion = `${major}.${minor}`;
-  const cdnVersion = prerelease[0] ? `${majorMinorVersion}.${patch}-${prerelease[0]}` : `${majorMinorVersion}.${patch}`;
-  return {
-    major,
-    minor,
-    patch,
-    prerelease,
-    majorMinorVersion,
-    cdnVersion
-  };
-};
-function getSystemVersion() {
-  const repositoryRoot = findRepositoryRoot();
-  const version = retrievePackageJson(repositoryRoot).version;
-  if (!version) {
-    throw new Error("Root package.json does not have a version defined");
-  }
-  return { version, ...parseVersion(version) };
-}
-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 {
-  detectPackageManager,
-  findRepositoryRoot,
-  getSystemVersion,
-  getTurboPath,
-  parseVersion,
-  setRootTargetFile,
-  workspacePackagesWalker
-};