@arcgis/node-toolkit 5.2.0-next.90 → 5.2.0-next.91

package/dist/file.d.ts

@@ -2,21 +2,36 @@
  * Asynchronously check if a file or directory exists.
  * Using un-promisified version because promises version creates exceptions
  * which interferes with debugging when "Pause on caught exceptions" is enabled
+ *
+ * @public
+ * @param file
  */
 export declare const existsAsync: (file: string) => Promise<boolean>;
 /**
  * Create a file with the specified content if it does not already exist.
+ *
+ * @public
+ * @param filePath
+ * @param content
  */
 export declare function createFileIfNotExists(filePath: string, content: string): Promise<void>;
 /**
  * Climb the directory tree upward, until it founds a directory that contains the
  * target file, and return resulting full path.
  * Returns `undefined` if the file is not found.
+ *
+ * @public
+ * @param target
+ * @param startDirectory
  */
 export declare function findPath(target: string, startDirectory?: string): string | undefined;
 /**
  * Asynchronously climb the directory tree upward, until it founds a directory that contains the
  * target file, and return resulting full path.
  * Returns `undefined` if the file is not found.
+ *
+ * @public
+ * @param target
+ * @param startDirectory
  */
 export declare function asyncFindPath(target: string, startDirectory?: string): Promise<string | undefined>;

package/dist/glob.d.ts

@@ -1,6 +1,8 @@
 /**
  * Read `.gitignore` files and convert it to globs that are accepted by ESLint
  *
+ * @public
+ * @param filePath
  * @example
  * ```ts
  * // eslint.config.js
@@ -18,6 +20,8 @@
  */
 export declare function gitIgnoreFileToGlobs(filePath: string): string[];
 /**
+ * @public
+ * @param pattern
  * @deprecated Use gitIgnoreFileToGlobs from "@arcgis/node-toolkit/glob"
  * instead
  */

package/dist/packageJson.d.ts

@@ -4,62 +4,101 @@
  *
  * The full package.json type is insanely large (20k lines):
  * https://github.com/ffflorian/schemastore-updater/blob/main/schemas/package/index.d.ts#L20067
+ *
+ * @public
  */
 export type PackageJson = {
+    /** @public */
     "name": string;
+    /** @public */
     "version": string;
+    /** @public */
     "private"?: boolean;
+    /** @public */
     "type"?: "commonjs" | "module";
+    /** @public */
     "main"?: string;
+    /** @public */
     "module"?: string;
+    /** @public */
     "types"?: string;
+    /** @public */
     "files"?: string[];
+    /** @public */
     "bin"?: Record<string, string> | string;
+    /** @public */
     "man"?: string[] | string;
     /**
+     * @public
      * @see https://pnpm.io/package_json#publishconfigdirectory
      */
     "publishConfig"?: {
         directory?: string;
         linkDirectory?: boolean;
     };
+    /** @public */
     "dependencies"?: Record<string, string>;
+    /** @public */
     "devDependencies"?: Record<string, string>;
+    /** @public */
     "peerDependencies"?: Record<string, string>;
+    /** @public */
     "peerDependenciesMeta"?: Record<string, {
         optional?: boolean;
     }>;
+    /** @public */
     "optionalDependencies"?: Record<string, string>;
+    /** @public */
     "css.customData"?: string[];
+    /** @public */
     "customElements"?: string;
+    /** @public */
     "html.customData"?: string[];
+    /** @public */
     "web-types"?: string;
+    /** @public */
     "exports"?: Record<string, Record<string, string> | string>;
+    /** @public */
     "engines"?: {
         node?: string;
     };
+    /** @public */
     "scripts"?: Record<string, string>;
+    /** @public */
     "packageManager"?: string;
 };
 /**
  * Synchronously retrieves the package.json file for the current project or a specified location.
  * If the location is not specified, it will search for the package.json file starting from the current working directory.
  * This function caches the package.json file for future calls to avoid unnecessary file system reads.
+ *
+ * @public
+ * @param location
  */
 export declare function retrievePackageJson(location?: string): PackageJson;
 /**
  * Asynchronously retrieves the package.json file for the current project or a specified location.
  * If the location is not specified, it will search for the package.json file starting from the current working directory.
  * This function caches the package.json file for future calls to avoid unnecessary file system reads.
+ *
+ * @public
+ * @param location
  */
 export declare function asyncRetrievePackageJson(location?: string): Promise<PackageJson>;
 /**
  * Returns an absolute path to the root of a package in node_modules, without
  * trailing slash.
+ *
+ * @public
+ * @param packageName
+ * @param cwd
  */
 export declare function fetchPackageLocation(packageName: string, cwd?: string): Promise<string>;
 /**
  * Find the package.json for a given package name in node_modules, and return the parsed JSON.
  * Returns undefined if the package.json cannot be found.
+ *
+ * @public
+ * @param packageName
  */
 export declare function findPackageJson(packageName: string): PackageJson | undefined;

package/dist/path.d.ts

@@ -1,18 +1,31 @@
-import { posix } from 'path';
+/**
+ * See ../path.md for details about our path handling.
+ *
+ * DOCS: publish to webgis reference docs for this package, and the ./path.md file
+ */
+import { posix } from "path";
 /**
  * Determines if the current environment is POSIX (e.g., macOS, Linux) or not.
  * 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)
+ *
+ * @public
  */
 export declare const isPosix: boolean;
 /**
  * Converts a Windows-style path to a POSIX-style path.
+ *
+ * @public
+ * @param relativePath The path to convert to POSIX-style separators.
  */
 export declare const toPosixPathSeparators: (relativePath: string) => string;
 /**
  * Normalizes the path separators for the current runtime environment.
  * On POSIX systems, this function returns the path unchanged.
  * On Windows systems, it converts all `\` separators to `/`.
+ *
+ * @public
+ * @param path The path to normalize.
  */
 export declare const normalizePath: (relativePath: string) => string;
 /**
@@ -21,16 +34,23 @@ export declare const normalizePath: (relativePath: string) => string;
  * 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).
+ *
+ * @public
+ * @param relativePath
  */
 export declare const toSystemPathSeparators: (relativePath: string) => string;
 /**
  * Like `process.cwd()`, but always returns a POSIX-style path
  * (with `/` as separator).
+ *
+ * @public
  */
 export declare const getCwd: () => string;
 /**
  * A wrapper for Node.js's `path` module that always uses POSIX-style paths
  * (with `/` as separator).
+ *
+ * @public
  */
 export declare const path: typeof posix & {
     sep: "/";

package/dist/path.js

@@ -6,7 +6,7 @@ const toPosixPathSeparators = (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 toSystemPathSeparators = isPosix ? (relativePath) => relativePath : toWin32PathSeparators;
 const getCwd = isPosix ? process.cwd : () => toPosixPathSeparators(process.cwd());
 const path = isPosix ? posix : {
   ...win32,

package/dist/shell.d.ts

@@ -1,51 +1,67 @@
-import { ExecOptionsWithStringEncoding, ExecSyncOptionsWithStringEncoding, SpawnSyncOptionsWithStringEncoding, SpawnOptions } from 'node:child_process';
+import { type ExecOptionsWithStringEncoding, type ExecSyncOptionsWithStringEncoding, type SpawnSyncOptionsWithStringEncoding, type SpawnOptions } from "node:child_process";
+/** @public */
 type SyncProcessOptions = Omit<SpawnSyncOptionsWithStringEncoding, "stdio">;
+/** @public */
 type CollectOutputSyncOptions = SyncProcessOptions & {
+    /** @public */
     stderr?: "ignore" | "inherit";
 };
+/** @public */
 type AsyncProcessOptions = SpawnOptions & {
+    /** @public */
     input?: NonNullable<SpawnSyncOptionsWithStringEncoding["input"]>;
 };
 /**
  * Synchronously execute a shell command and return the output.
  *
- * Prefer {@link runCommandSync} for command-only execution, or {@link collectOutputSync}
- * when you need to capture stdout. {@link sh} goes through a shell, which
+ * Prefer {@link shell!runCommandSync} for command-only execution, or {@link shell!collectOutputSync}
+ * when you need to capture stdout. {@link shell!sh} goes through a shell, which
  * requires careful escaping and can mis-handle dynamic input with spaces or
  * shell metacharacters.
  *
- * Use {@link sh} only when shell features are intentionally required, such as
+ * Use {@link shell!sh} only when shell features are intentionally required, such as
  * pipes, redirects, `&&`, or command substitution.
  *
  * Example (shell features required):
  * `sh("pnpm list | grep @arcgis/core")`
+ *
+ * @public
+ * @param command
+ * @param options
  */
 export declare function sh(command: string, options?: Partial<ExecSyncOptionsWithStringEncoding>): string;
 /**
  * Asynchronously execute a shell command and return the output.
  *
- * Prefer {@link runCommand} for command-only execution, or {@link collectOutput}
- * when you need to capture stdout. {@link asyncSh} executes through a shell,
+ * Prefer {@link shell!runCommand} for command-only execution, or {@link shell!collectOutput}
+ * when you need to capture stdout. {@link shell!asyncSh} executes through a shell,
  * so callers must handle shell escaping and quoting correctly.
  *
- * Use {@link asyncSh} only when shell syntax is intentionally needed.
+ * Use {@link shell!asyncSh} only when shell syntax is intentionally needed.
  *
  * Example (shell features required):
  * `await asyncSh("pnpm list | grep @arcgis/core")`
+ *
+ * @param command
+ * @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 sh} because arguments are passed as
+ * 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 sp} only when you explicitly need shell features.
- * @deprecated Use {@link collectOutputSync} or {@link runCommandSync} instead.
+ * 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;
 /**
@@ -55,6 +71,11 @@ export declare function sp(command: string, args: string[], options?: Partial<Sp
  * if the `shell` option is not explicitly provided.
  * Note 2:
  * If the `input` option is provided, it will be piped to the child process's stdin.
+ *
+ * @public
+ * @param command
+ * @param args
+ * @param options
  */
 export declare function runCommandSync(command: string, args: string[], options?: Partial<SyncProcessOptions>): void;
 /**
@@ -64,16 +85,31 @@ export declare function runCommandSync(command: string, args: string[], options?
  * if the `shell` option is not explicitly provided.
  * Note 2:
  * If the `input` option is provided, it will be piped to the child process's stdin.
+ *
+ * @public
+ * @param command
+ * @param args
+ * @param options
  */
 export declare function runCommand(command: string, args: string[], options?: Partial<AsyncProcessOptions>): Promise<void>;
 /**
  * Synchronously execute a command and collect stdout while streaming stderr.
  * Note that `pnpm` command will be automatically invoked with `shell: process.platform === "win32"`.
+ *
+ * @public
+ * @param command
+ * @param args
+ * @param options
  */
 export declare function collectOutputSync(command: string, args: string[], options?: Partial<CollectOutputSyncOptions>): string;
 /**
  * Asynchronously execute a command and collect stdout while streaming stderr.
  * Note that `pnpm` command will be automatically invoked with `shell: process.platform === "win32"`.
+ *
+ * @public
+ * @param command
+ * @param args
+ * @param options
  */
 export declare function collectOutput(command: string, args: string[], options?: Partial<AsyncProcessOptions>): Promise<string>;
 export {};

package/dist/vite/externalizeDependenciesPlugin.d.ts

@@ -1,13 +1,16 @@
-import { Plugin } from 'vite';
-import { PackageJson } from '../packageJson.ts';
+import type { Plugin } from "vite";
+import { type PackageJson } from "../packageJson.ts";
 /**
  * Options for managing dependencies in a Vite project.
+ *
+ * @public
  */
 export type DependencyManagementOptions = {
     /**
      * Force bundle in these dependencies even if they are declared as
      * dependencies or peerDependencies.
      *
+     * @public
      * @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
@@ -25,6 +28,7 @@ export type DependencyManagementOptions = {
      * Force externalize these dependencies, even if they are declared as
      * devDependencies.
      *
+     * @public
      * @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
@@ -36,6 +40,7 @@ export type DependencyManagementOptions = {
      * to avoid bundling in dependencies in a library. In application packages,
      * bundling in everything is desirable, so enable this option.
      *
+     * @public
      * @default false
      */
     readonly isApplication?: boolean;
@@ -61,11 +66,11 @@ export type DependencyManagementOptions = {
  *   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
+ * > If a dependency is both a peerDependency and a devDependency, it will still
+ * > be externalized (because all peerDependencies are externalized).
  *
- * @remarks
- * If a dependency is both a peerDependency and a devDependency, it will still
- * be externalized (because all peerDependencies are externalized).
+ * @public
+ * @param options
  */
 export declare function externalizeDependencies(options: DependencyManagementOptions): Plugin;
 interface PluginShape extends Plugin {

package/dist/vite/installPlaywright.d.ts

@@ -1,3 +1,3 @@
-import { Plugin } from 'vite';
+import type { Plugin } from "vite";
 /** @public */
 export declare function installPlaywright(): Plugin;

package/dist/vite/presetPlugin.d.ts

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

package/dist/vite/simpleTypesEmit.d.ts

@@ -0,0 +1,19 @@
+import type { Plugin } from "vite";
+/**
+ * A barebones tsc integration for Vite.
+ * This emits types for all .ts and .tsx files in src/ using tsconfig.json.
+ *
+ * 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
+ * cyclical dependency.
+ *
+ * This serves as a minimal replacement for vite-plugin-dts. For comparison,
+ * node-toolkit build using this package in 1s compared to 1.3s for
+ * vite-plugin-dts.
+ *
+ * @public
+ */
+export declare function simpleTypesEmit(): Plugin;

package/dist/vite/simpleTypesEmit.js

@@ -0,0 +1,76 @@
+import ts from "typescript";
+import { loadTypeScriptConfig } from "./typeScript.js";
+import { path } from "../path.js";
+import { mkdir, writeFile } from "node:fs/promises";
+function simpleTypesEmit() {
+  let oldProgram;
+  let isWatchMode = false;
+  const sourcePrefix = path.join(process.cwd(), "src/");
+  const distPrefix = path.join(process.cwd(), "dist/");
+  const distSrcPrefix = path.join(distPrefix, "src/");
+  return {
+    name: "simple-types-emit",
+    apply: "build",
+    configResolved(viteConfig) {
+      const isBuildMode = viteConfig.command === "build";
+      isWatchMode = (isBuildMode ? viteConfig.build.watch : viteConfig.server.watch) != null;
+    },
+    writeBundle: {
+      sequential: true,
+      async handler() {
+        const { config } = loadTypeScriptConfig(void 0, void 0, true);
+        const compilerHost = ts.createCompilerHost(config.options);
+        const program = ts.createProgram(
+          config.fileNames,
+          { ...config.options, noEmit: false, declaration: true, emitDeclarationOnly: true },
+          compilerHost,
+          oldProgram
+        );
+        oldProgram = program;
+        const allDiagnostics = [...ts.getPreEmitDiagnostics(program)];
+        const writeQueue = [];
+        for (const sourceFile of program.getSourceFiles()) {
+          if (!isIncludedFile(sourceFile.fileName, sourcePrefix)) {
+            continue;
+          }
+          const diagnostics = program.emit(
+            sourceFile,
+            (name, text) => {
+              const filePath = distPrefix + name.slice(distSrcPrefix.length);
+              writeQueue.push(
+                mkdir(path.dirname(filePath), { recursive: true }).then(async () => await writeFile(filePath, text))
+              );
+            },
+            void 0,
+            true
+          );
+          allDiagnostics.push(...diagnostics.diagnostics);
+        }
+        await Promise.all(writeQueue);
+        const deduplicatedDiagnostics = ts.sortAndDeduplicateDiagnostics(allDiagnostics);
+        const hasErrors = deduplicatedDiagnostics.length > 0;
+        const stopBuild = hasErrors && !isWatchMode;
+        if (stopBuild) {
+          console.error(
+            ts.formatDiagnosticsWithColorAndContext(deduplicatedDiagnostics, {
+              getCurrentDirectory: ts.sys.getCurrentDirectory,
+              getCanonicalFileName: (fileName) => fileName,
+              getNewLine: () => ts.sys.newLine
+            })
+          );
+          const error = new Error("TypeScript errors reported. See error messages above");
+          error.stack = "";
+          throw error;
+        }
+      }
+    }
+  };
+}
+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.");
+const isStoryFile = (filePath) => filePath.includes(".stories.");
+const isInIncludedFolder = (fileOrFolderPath, prefix) => fileOrFolderPath.startsWith(prefix) && !fileOrFolderPath.includes("node_modules");
+export {
+  simpleTypesEmit
+};

package/dist/vite/typeScript.d.ts

@@ -0,0 +1,21 @@
+import ts from "typescript";
+/** @public */
+export interface TypeScriptConfigResult {
+    /**
+     * Absolute path to the resolved tsconfig.json file.
+     *
+     * @public
+     */
+    configPath: string;
+    /** @public */
+    config: ts.ParsedCommandLine;
+}
+/**
+ * @public
+ * @param cwd Defaults to process.cwd()
+ * @param configPath Optional absolute or relative path to a tsconfig.json file.
+ * @param resolveIncludedFiles If true, will resolve tsconfig's include, exclude,
+ * and files globs. Resolved files can be accessed via
+ * TypeScriptConfigResult.config.fileNames.
+ */
+export declare function loadTypeScriptConfig(cwd: string | undefined, configPath: string | undefined, resolveIncludedFiles: boolean): TypeScriptConfigResult;

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

@@ -1,21 +1,31 @@
 /**
  * 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");
@@ -37,11 +47,16 @@ export declare const parseVersion: (version: string) => {
  * 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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arcgis/node-toolkit",
-  "version": "5.2.0-next.90",
+  "version": "5.2.0-next.91",
   "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",
@@ -13,6 +13,8 @@
     "./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"
   },
@@ -23,6 +25,7 @@
   "dependencies": {
     "@types/node": "~24.11.2",
     "tslib": "^2.8.1",
+    "typescript": "~6.0.3",
     "vite": "^7.3.2",
     "vite-plugin-dts": "^4.5.4"
   }