@arcgis/node-toolkit 5.2.0-next.100

package/dist/vite/typeScript.js

@@ -0,0 +1,40 @@
+import ts from "typescript";
+import { findPath } from "../file.js";
+import { path, toSystemPathSeparators } from "../path.js";
+function loadTypeScriptConfig(cwd = process.cwd(), configPath, resolveIncludedFiles) {
+  const tsConfigFile = configPath === void 0 ? findPath("tsconfig.json", cwd) : path.resolve(cwd, configPath);
+  if (tsConfigFile === void 0) {
+    throw Error(
+      `Unable to find ${toSystemPathSeparators(String(configPath))}. Please make sure the file exists, or provide types.tsconfigPath option to useLumina()`
+    );
+  }
+  const parsed = ts.readConfigFile(tsConfigFile, ts.sys.readFile);
+  if (parsed.error !== void 0) {
+    throw Error(ts.formatDiagnosticsWithColorAndContext([parsed.error], diagnosticsContext));
+  }
+  const typedResolvedConfig = parsed.config;
+  const fastConfig = resolveIncludedFiles ? typedResolvedConfig : {
+    ...typedResolvedConfig,
+    include: [],
+    files: [],
+    exclude: []
+  };
+  const resolved = ts.parseJsonConfigFileContent(fastConfig, ts.sys, path.dirname(tsConfigFile));
+  const noFilesFoundErrorCode = 18002;
+  const filteredErrors = resolveIncludedFiles ? resolved.errors : resolved.errors.filter((error) => error.code !== noFilesFoundErrorCode);
+  if (filteredErrors.length > 0) {
+    throw Error(ts.formatDiagnosticsWithColorAndContext(filteredErrors, diagnosticsContext));
+  }
+  return {
+    configPath: tsConfigFile,
+    config: resolved
+  };
+}
+const diagnosticsContext = {
+  getCurrentDirectory: process.cwd,
+  getCanonicalFileName: (fileName) => fileName,
+  getNewLine: () => ts.sys.newLine
+};
+export {
+  loadTypeScriptConfig
+};

package/dist/workspace.d.ts

@@ -0,0 +1,62 @@
+/**
+ * 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.
+ *
+ * @public
+ * @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.
+ *
+ * @public
+ */
+export declare function findRepositoryRoot(): string;
+/**
+ * Get the path to the Turbo CLI. This allows us to directly invoke it without incurring the overhead of going through
+ * the package manager.
+ *
+ * @public
+ * @param repositoryRoot
+ */
+export declare function getTurboPath(repositoryRoot?: string): string;
+/**
+ * Parse a version string into its components.
+ *
+ * @public
+ * @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).
+ *
+ * @public
+ */
+export declare function getSystemVersion(): ReturnType<typeof parseVersion> & {
+    version: string;
+};
+/**
+ * Detect if current repository/monorepo uses npm, pnpm, or yarn
+ *
+ * @public
+ * @param cwd
+ */
+export declare function detectPackageManager(cwd?: string): string;

package/dist/workspace.js

@@ -0,0 +1,78 @@
+import { findPath } from "./file.js";
+import { retrievePackageJson } from "./packageJson.js";
+import { path } from "./path.js";
+import { existsSync, readFileSync } from "node:fs";
+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);
+}
+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
+};

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@arcgis/node-toolkit",
+  "version": "5.2.0-next.100",
+  "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",
+    "./shell": "./dist/shell.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",
+    "./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": [
+    "dist/"
+  ],
+  "license": "SEE LICENSE IN LICENSE.md",
+  "dependencies": {
+    "@types/node": "~24.11.2",
+    "tslib": "^2.8.1",
+    "typescript": "~6.0.3",
+    "vite": "^7.3.2",
+    "vite-plugin-dts": "^4.5.4"
+  }
+}