@arcgis/node-toolkit 6.0.0-next.2 → 6.0.0-next.20

package/dist/env.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Reads the .env file and loads the environment variables.
+ *
+ * @param searchRoot Set this to `import.meta.dirname`. If no `.env` file is found, will search at `process.cwd()`.
+ */
+export declare function readEnvFile(searchRoot: string): void;

package/dist/env.js

@@ -0,0 +1,10 @@
+import { findPath } from "./file.js";
+function readEnvFile(searchRoot) {
+  const envFile = findPath(".env", searchRoot) ?? findPath(".env");
+  if (envFile !== void 0) {
+    process.loadEnvFile(envFile);
+  }
+}
+export {
+  readEnvFile
+};

package/dist/glob.d.ts

@@ -19,10 +19,3 @@
  * ```
  */
 export declare function gitIgnoreFileToGlobs(filePath: string): string[];
-/**
- * @public
- * @param pattern
- * @deprecated Use gitIgnoreFileToGlobs from "@arcgis/node-toolkit/glob"
- * instead
- */
-export declare const gitIgnoreToGlob: (pattern: string) => string;

package/dist/glob.js

@@ -1,8 +1,7 @@
 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);
+  return readFileSync(filePath, "utf8").split("\n").filter((line) => line.trim().length > 0 && !line.trim().startsWith("#")).map((pattern) => fixAbsoluteSyntax(fixMatchFilesSyntax(pattern.trim())));
 }
-const gitIgnoreToGlob = (pattern) => fixAbsoluteSyntax(fixMatchFilesSyntax(pattern.trim()));
 function fixAbsoluteSyntax(pattern) {
   if (pattern.startsWith("/")) {
     return pattern.slice(1);
@@ -23,6 +22,5 @@ function fixMatchFilesSyntax(pattern) {
   return pattern.endsWith("/*") ? `${pattern}*` : pattern.endsWith("/") ? `${pattern}**` : `${pattern}/**`;
 }
 export {
-  gitIgnoreFileToGlobs,
-  gitIgnoreToGlob
+  gitIgnoreFileToGlobs
 };

package/dist/markdown.d.ts

@@ -0,0 +1,9 @@
+export declare const markdownTextLimit = 65000;
+/**
+ * Split markdown to fit into GitHub comment length limit. Splits at best available
+ * places: headings (higher levels first), code blocks and details sections, blank lines.
+ *
+ * Use cases: automated reports in issues, pull request check status comments,
+ * reporting public API diff inside a pr comment.
+ */
+export declare function splitMarkdown(content: string, limit?: number): string[];

package/dist/markdown.js

@@ -0,0 +1,103 @@
+const markdownTextLimit = 65e3;
+const boundaryKinds = ["heading", "block", "blank", "line", "text"];
+function splitMarkdown(content, limit = markdownTextLimit) {
+  if (!Number.isSafeInteger(limit) || limit < 2) {
+    throw new Error("Markdown limit must be an integer of at least 2.");
+  }
+  const chunks = [];
+  let start = 0;
+  let blocks = [];
+  let prefix = "";
+  while (prefix.length + content.length - start > limit) {
+    const remaining = content.slice(start);
+    const split = getBoundary(remaining, limit - prefix.length, blocks, start === 0 || content[start - 1] === "\n");
+    chunks.push(
+      prefix + remaining.slice(0, split.index) + closeBlocks(split.blocks, remaining[split.index - 1] === "\n")
+    );
+    start += split.index;
+    blocks = split.blocks;
+    prefix = openBlocks(blocks);
+  }
+  chunks.push(prefix + content.slice(start));
+  return chunks;
+}
+function getBoundary(content, limit, initialBlocks, atLineStart) {
+  const blocks = [...initialBlocks];
+  let best;
+  let skipEnd = 0;
+  for (const match of content.matchAll(/[^\n]*(?:\n|$)/gu)) {
+    const index = match.index;
+    if (index > limit) {
+      break;
+    }
+    const line = match[0];
+    const end = index + line.length;
+    let textStart = Math.max(index, skipEnd);
+    if (end <= textStart) {
+      continue;
+    }
+    const aligned = textStart === index && (index > 0 || atLineStart);
+    const fence = aligned ? /^ {0,3}(`{3,}|~{3,})([^\r\n]*)/u.exec(line) : null;
+    const activeFence = blocks.at(-1)?.fence;
+    const heading = aligned && activeFence === void 0 ? /^ {0,3}(#{1,6})\s/u.exec(line) : null;
+    const opening = aligned && activeFence === void 0 ? /^[ \t]*<details\b[^>]*>(?:\s*<summary\b[^>]*>[\s\S]*?<\/summary\s*>)?/iu.exec(content.slice(index)) : null;
+    const kind = !aligned ? "text" : activeFence !== void 0 ? "line" : opening !== null || fence !== null ? "block" : heading !== null ? "heading" : /^\s*$/u.test(line) ? "blank" : "line";
+    consider(textStart, kind, heading?.[1].length);
+    if (activeFence !== void 0) {
+      if (fence !== null && fence[1].startsWith(activeFence[0]) && fence[1].length >= activeFence.length && fence[2].trim() === "") {
+        blocks.pop();
+        textStart = end;
+      }
+    } else if (fence !== null) {
+      blocks.push({ opening: line.trimEnd(), closing: fence[1], fence: fence[1] });
+      textStart = end;
+    } else if (aligned && /^\s*<!--/u.test(line)) {
+      const closing = content.indexOf("-->", index);
+      textStart = closing === -1 ? content.length : closing + 3;
+    } else if (opening !== null) {
+      if (/<\/details\s*>/iu.test(line)) {
+        textStart = end;
+      } else {
+        blocks.push({ opening: opening[0], closing: "</details>" });
+        textStart = index + opening[0].length;
+      }
+    } else if (aligned && /^\s*<\/details\s*>/iu.test(line)) {
+      blocks.pop();
+      textStart = end;
+    }
+    skipEnd = textStart;
+    if (textStart <= end) {
+      consider(end, line.endsWith("\n") ? "line" : "text");
+      let exact = Math.min(end, limit - closeBlocks(blocks).length);
+      if (/[\uD800-\uDBFF]/u.test(content[exact - 1]) && /[\uDC00-\uDFFF]/u.test(content[exact])) {
+        exact--;
+      }
+      if (exact >= textStart) {
+        consider(exact, "text");
+      }
+    }
+  }
+  if (best === void 0) {
+    throw new Error("Markdown limit is too small to split the enclosing blocks.");
+  }
+  return best;
+  function consider(index, kind, headingLevel = 0) {
+    if (index <= 0 || index + closeBlocks(blocks, content[index - 1] === "\n").length > limit) {
+      return;
+    }
+    if (best === void 0 || boundaryKinds.indexOf(kind) < boundaryKinds.indexOf(best.kind) || kind === best.kind && (headingLevel < best.headingLevel || headingLevel === best.headingLevel && index > best.index)) {
+      best = { index, kind, headingLevel, blocks: [...blocks] };
+    }
+  }
+}
+function closeBlocks(blocks, endsWithNewline = false) {
+  return blocks.length === 0 ? "" : `${endsWithNewline ? "" : "\n"}${blocks.toReversed().map(({ closing }) => closing).join("\n")}
+`;
+}
+function openBlocks(blocks) {
+  return blocks.map(({ opening, fence }) => opening + (fence === void 0 ? "\n\n" : "\n")).join("");
+}
+export {
+  markdownTextLimit,
+  splitMarkdown
+};

package/dist/packageJson.d.ts

@@ -51,7 +51,7 @@ export type PackageJson = {
     /** @public */
     "css.customData"?: string[];
     /** @public */
-    "customElements"?: string;
+    "customElements"?: string[] | string;
     /** @public */
     "html.customData"?: string[];
     /** @public */

package/dist/shell.d.ts

@@ -46,24 +46,6 @@ export declare function sh(command: string, options?: Partial<ExecSyncOptionsWit
  * @param options
  */
 export declare function asyncSh(command: string, options?: Partial<ExecOptionsWithStringEncoding>): Promise<string>;
-/**
- * Synchronously execute a command without shell interpolation and return the output.
- *
- * This is usually safer than {@link shell!sh} because arguments are passed as
- * discrete tokens, which avoids most shell escaping issues and command
- * injection pitfalls.
- *
- * Example:
- * `sp("git", ["show", `${baseRef}:pnpm-workspace.yaml`])`
- *
- * Avoid {@link shell!sp} only when you explicitly need shell features.
- * @public
- * @deprecated Use {@link shell!collectOutputSync} or {@link shell!runCommandSync} instead.
- * @param command
- * @param args
- * @param options
- */
-export declare function sp(command: string, args: string[], options?: Partial<SpawnSyncOptionsWithStringEncoding>): string;
 /**
  * Synchronously execute a command and stream output to the current process.
  * Note 1:

package/dist/shell.js

@@ -43,26 +43,6 @@ ${output}`;
     });
   }
 }
-function sp(command, args, options = {}) {
-  if (process.platform === "win32" && command === "pnpm" && // Allow explicit shell config including shell:false for environment-specific handling.
-  !("shell" in options)) {
-    throw Error(
-      'If invoking pnpm on Windows, provide { shell: true } or { shell: process.platform === "win32" } and handle shell escaping.'
-    );
-  }
-  const normalizedOptions = { encoding: "utf8", ...options };
-  const result = spawnSync(command, args, normalizedOptions);
-  if (result.error) {
-    throw result.error;
-  }
-  const sep = result.stdout && result.stderr ? "\n" : "";
-  const output = `${result.stdout ?? ""}${sep}${result.stderr ?? ""}`.trim();
-  const exitCode = result.status ?? 0;
-  if (exitCode !== 0) {
-    throw makeSpawnError(command, args, exitCode, result.signal, output);
-  }
-  return output;
-}
 function runCommandSync(command, args, options = {}) {
   const fixedOptions = fixPnpmUsage(command, options);
   const { input } = fixedOptions;
@@ -155,6 +135,5 @@ export {
   collectOutputSync,
   runCommand,
   runCommandSync,
-  sh,
-  sp
+  sh
 };

package/dist/vite/installPlaywright.js

@@ -2,7 +2,7 @@ import { mkdir, rm, stat } from "node:fs/promises";
 import { homedir } from "node:os";
 import { join } from "node:path";
 import { findPath, existsAsync } from "../file.js";
-import { runCommand } from "../shell.js";
+import { runCommand, collectOutput } from "../shell.js";
 import { pathToFileURL } from "node:url";
 let installPromise;
 function installPlaywright() {
@@ -26,7 +26,20 @@ async function ensureInstalled() {
     throw new Error("Playwright not found in node_modules. Please install it first.");
   }
   const { chromium } = await import(pathToFileURL(join(playwrightCwd, "index.mjs")).href);
-  if (await existsAsync(chromium.executablePath())) {
+  const executablePath = chromium.executablePath();
+  const isReady = async () => {
+    if (!await existsAsync(executablePath)) {
+      return false;
+    }
+    if (process.platform === "linux" && process.env.CI) {
+      const dependencies = await collectOutput("ldd", [executablePath], {
+        env: { ...process.env, [`LC_ALL`]: "C" }
+      });
+      return !dependencies.includes("=> not found");
+    }
+    return true;
+  };
+  if (await isReady()) {
     return;
   }
   const home = homedir();
@@ -36,7 +49,7 @@ async function ensureInstalled() {
   await mkdir(stateDir, { recursive: true });
   const releaseLock = await acquireLock(lockPath);
   try {
-    if (await existsAsync(chromium.executablePath())) {
+    if (await isReady()) {
       return;
     }
     const installArgs = [

package/dist/vite/presetPlugin.d.ts

@@ -1,16 +1,7 @@
 import type { Plugin } from "vite";
-import type dts from "vite-plugin-dts";
 import { type DependencyManagementOptions } from "./externalizeDependenciesPlugin.ts";
 /** @public */
-export type VitePresetOptions = DependencyManagementOptions & {
-    /**
-     * Options for `vite-plugin-dts`
-     *
-     * @public
-     * @deprecated Use https://webgis.esri.com/references/api-extractor/integrations instead
-     */
-    dtsOptions?: Parameters<typeof dts>[0] | false;
-};
+export type VitePresetOptions = DependencyManagementOptions;
 /**
  * Vite preset for all our support packages:
  * - externalizes all non-dev-dependencies
@@ -18,4 +9,4 @@ export type VitePresetOptions = DependencyManagementOptions & {
  * @public
  * @param options
  */
-export declare function vitePresetPlugin({ dtsOptions, externalize, bundleIn, isApplication }?: VitePresetOptions): [Plugin, Plugin, Promise<Plugin> | undefined];
+export declare function vitePresetPlugin({ externalize, bundleIn, isApplication }?: VitePresetOptions): [Plugin, Plugin];

package/dist/vite/presetPlugin.js

@@ -1,24 +1,13 @@
-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.");
-}
 const hashlessOutputNames = {
   assetFileNames: "assets/[name][extname]",
   chunkFileNames: "chunks/[name].js"
 };
-function vitePresetPlugin({ dtsOptions = {}, externalize, bundleIn, isApplication } = {
-  externalize: [],
-  dtsOptions: {}
-}) {
-  const dist = `${path.resolve("dist")}/`;
-  const distSrc = `${dist}src/`;
-  let command = void 0;
+function vitePresetPlugin({ externalize, bundleIn, isApplication } = { externalize: [] }) {
   return [
     {
       name: "vite-preset-config",
       config(config, env) {
-        command = env.command;
         const { rollupOptions, ssr, target } = config.build ?? {};
         const isBrowserApplication = isApplication && !ssr && !env.isSsrBuild;
         const output = rollupOptions?.output;
@@ -40,44 +29,7 @@ function vitePresetPlugin({ dtsOptions = {}, externalize, bundleIn, isApplicatio
       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 {

package/package.json

@@ -1,12 +1,14 @@
 {
   "name": "@arcgis/node-toolkit",
-  "version": "6.0.0-next.2",
+  "version": "6.0.0-next.20",
   "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",
+    "./env": "./dist/env.js",
     "./file": "./dist/file.js",
+    "./markdown": "./dist/markdown.js",
     "./shell": "./dist/shell.js",
     "./glob": "./dist/glob.js",
     "./path": "./dist/path.js",
@@ -27,7 +29,6 @@
     "picomatch": "^4.0.4",
     "tslib": "^2.8.1",
     "typescript": "~6.0.3",
-    "vite": "^7.3.2",
-    "vite-plugin-dts": "^4.5.4"
+    "vite": "^7.3.2"
   }
 }