@arcgis/node-toolkit 5.2.0-next.100

package/dist/shell.js

@@ -0,0 +1,160 @@
+import { exec, spawn, spawnSync, execSync } from "node:child_process";
+import { styleText } from "node:util";
+function sh(command, options = {}) {
+  try {
+    const normalizedOptions = { encoding: "utf8", ...options };
+    return execSync(command.trim(), normalizedOptions).trim();
+  } catch (error) {
+    makeExecErrorReadable(error);
+    throw error;
+  }
+}
+async function asyncSh(command, options = {}) {
+  const normalizedOptions = { encoding: "utf8", ...options };
+  return await new Promise((resolve, reject) => {
+    exec(command.trim(), normalizedOptions, (error, stdout, stderr) => {
+      if (error) {
+        makeExecErrorReadable(error);
+        reject(error);
+        return;
+      }
+      resolve(stdout.trim() || stderr.trim());
+    });
+  });
+}
+function makeExecErrorReadable(error) {
+  if (error instanceof Error && error.stack && "output" in error && Array.isArray(error.output) && "status" in error) {
+    const stackIndex = error.stack.indexOf("\n    at ");
+    if (stackIndex !== -1) {
+      const output = error.output.filter(Boolean).join("\n").trim();
+      const newHeader = `${styleText("red", error.message)} (exit code: ${String(error.status)})
+${output}`;
+      const oldStackFrames = error.stack.substring(stackIndex);
+      error.stack = `Error: ${newHeader}${oldStackFrames}`;
+    }
+    Object.defineProperties(error, {
+      output: { enumerable: false },
+      stdout: { enumerable: false },
+      stderr: { enumerable: false },
+      signal: { enumerable: false },
+      status: { enumerable: false },
+      pid: { enumerable: false },
+      stdio: { enumerable: false }
+    });
+  }
+}
+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;
+  const stdio = input === void 0 ? "inherit" : ["pipe", "inherit", "inherit"];
+  const result = spawnSync(command, args, { stdio, ...fixedOptions });
+  assertSyncResultSuccess(command, args, result);
+}
+async function runCommand(command, args, options = {}) {
+  const fixedOptions = fixPnpmUsage(command, options);
+  const { input } = fixedOptions;
+  const stdio = input === void 0 ? "inherit" : ["pipe", "inherit", "inherit"];
+  const child = spawn(command, args, { stdio, ...fixedOptions });
+  if (input !== void 0) {
+    child.stdin?.end(input);
+  }
+  await new Promise((resolve, reject) => {
+    child.on("error", (error) => reject(error));
+    child.on("close", (code, signal) => {
+      if (code !== 0) {
+        reject(makeSpawnError(command, args, code, signal, ""));
+        return;
+      }
+      resolve();
+    });
+  });
+}
+function collectOutputSync(command, args, options = {}) {
+  const fixedOptions = fixPnpmUsage(command, options);
+  const { input, stderr = "inherit", ...spawnOptions } = fixedOptions;
+  const result = spawnSync(command, args, {
+    encoding: "utf8",
+    stdio: [input === void 0 ? "ignore" : "pipe", "pipe", stderr],
+    ...spawnOptions,
+    ...input === void 0 ? {} : { input }
+  });
+  assertSyncResultSuccess(command, args, result);
+  return (result.stdout ?? "").trim();
+}
+async function collectOutput(command, args, options = {}) {
+  const fixedOptions = fixPnpmUsage(command, options);
+  const { input } = fixedOptions;
+  const child = spawn(command, args, {
+    stdio: [input === void 0 ? "ignore" : "pipe", "pipe", "inherit"],
+    ...fixedOptions
+  });
+  if (input !== void 0) {
+    child.stdin?.end(input);
+  }
+  const stdoutChunks = [];
+  child.stdout?.on(
+    "data",
+    (chunk) => stdoutChunks.push(Buffer.isBuffer(chunk) ? chunk.toString("utf8") : String(chunk))
+  );
+  await new Promise((resolve, reject) => {
+    child.on("error", (error) => reject(error));
+    child.on("close", (code, signal) => {
+      if (code !== 0) {
+        reject(makeSpawnError(command, args, code, signal, ""));
+        return;
+      }
+      resolve();
+    });
+  });
+  return stdoutChunks.join("").trim();
+}
+function fixPnpmUsage(command, options) {
+  if (process.platform === "win32" && command === "pnpm") {
+    const fixedOptions = { shell: process.platform === "win32", ...options };
+    return fixedOptions;
+  }
+  return options;
+}
+function assertSyncResultSuccess(command, args, result) {
+  if (result.error) {
+    throw result.error;
+  }
+  if (result.status !== 0) {
+    throw makeSpawnError(command, args, result.status, result.signal, String(result.stderr ?? "").trim());
+  }
+}
+function makeSpawnError(command, args, code, signal, output) {
+  const commandText = `${command} ${args.join(" ")}`.trim();
+  const statusText = code !== null ? `exit code ${String(code)}` : `signal ${signal ?? "unknown"}`;
+  return new Error(`Command failed with ${statusText}: ${commandText}
+${output}`.trim());
+}
+export {
+  asyncSh,
+  collectOutput,
+  collectOutputSync,
+  runCommand,
+  runCommandSync,
+  sh,
+  sp
+};

package/dist/vite/externalizeDependenciesPlugin.d.ts

@@ -0,0 +1,96 @@
+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
+     * such as a devDependency, but there is a use case for declaring it as a
+     * dependency instead:
+     *
+     * - If TypeScript types from the bundled in dependencies are referenced in
+     *   the `.d.ts` files of your library, you will need to declare the package
+     *   as a `dependency`, so that it is still installed on the consumer's
+     *   computer so that TypeScript can correctly resolve the types of that
+     *   library.
+     */
+    readonly bundleIn?: (RegExp | string)[];
+    /**
+     * 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
+     * technical reasons.
+     */
+    readonly externalize?: (RegExp | string)[];
+    /**
+     * By default, this plugin errors if any devDependency is used in runtime code
+     * 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;
+};
+/**
+ * By default, Rollup will bundle-in all dependencies.
+ *
+ * We change it as follows:
+ * Externalize all packages that are defined as
+ * "dependency" or "peerDependency" in the package.json.
+ * If you wish to bundle-in some package, define it as a "devDependency".
+ *
+ * Bundling-in packages is not recommended because:
+ * - it makes our build take longer
+ * - it pushes larger packages to NPM
+ * - user of our library is locked into the version of the package we bundled in
+ * - if user has two packages using the same library, there will be two copies
+ *   served on the page
+ * - It may break some libraries/prevent them from optimizing correctly
+ *   depending on the production/development mode, or prevent them from loading
+ *   correct code depending on browser/node.js environment.
+ *
+ *   For example, see this statement from Lit:
+ *   https://lit.dev/docs/ssr/authoring/#:~:text=Don%27t%20bundle%20Lit,based%20on%20environment.
+ *
+ * > 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 {
+    resolveId: {
+        filter: {
+            id: {
+                include: RegExp[];
+                exclude: RegExp[] | undefined;
+            };
+        };
+        handler: (id: string, importer: string | undefined, options: {
+            isEntry: boolean;
+        }) => false | undefined;
+    };
+}
+declare function externalizeDependenciesImplementation(options: DependencyManagementOptions, packageJson: PackageJson): PluginShape;
+declare function matchesAny(id: string, patterns: readonly RegExp[]): boolean;
+export declare const exportsForTests: {
+    stringToStartsWithGlob: (option: RegExp | string) => RegExp;
+    externalizeDependenciesImplementation: typeof externalizeDependenciesImplementation;
+    matchesAny: typeof matchesAny;
+};
+export {};

package/dist/vite/externalizeDependenciesPlugin.js

@@ -0,0 +1,104 @@
+import { builtinModules } from "node:module";
+import { styleText } from "node:util";
+import { toPosixPathSeparators } from "../path.js";
+import { retrievePackageJson } from "../packageJson.js";
+function externalizeDependencies(options) {
+  return externalizeDependenciesImplementation(options, retrievePackageJson());
+}
+function externalizeDependenciesImplementation(options, packageJson) {
+  const externalDependencies = Object.keys({
+    ...packageJson.dependencies,
+    ...packageJson.peerDependencies,
+    ...packageJson.optionalDependencies
+  });
+  const isStrictBundling = toPosixPathSeparators(import.meta.dirname).includes("support-packages/node-toolkit");
+  const bundleIn = options.bundleIn?.map(stringToStartsWithGlob);
+  const explicitExternalize = options.externalize?.map(stringToStartsWithGlob) ?? [];
+  const externalize = [
+    ...explicitExternalize,
+    // BUG: we shouldn't silently externalize node in browser packages.
+    // Consider erroring instead
+    /^node:/u,
+    new RegExp(
+      `^(?:${externalDependencies.join("|")}${externalDependencies.length === 0 ? "" : "|"}${builtinModules.join("|")})(?:/|$)`,
+      "u"
+    )
+  ];
+  const plugin = {
+    name: pluginName,
+    apply: "build",
+    // Externalize before Vite's default resolution runs
+    enforce: "pre",
+    // Rolldown also has "external" option, which can be provided regexes.
+    // Theoretically that would be more efficient due to less communication
+    // overhead, but in practice they always evaluate it on the JS side:
+    // https://github.com/rolldown/rolldown/blob/4f996e637732a26ca04972975884abad5183292b/packages/rolldown/src/utils/bindingify-input-options.ts#L167
+    // https://github.com/rolldown/rolldown/blob/4f996e637732a26ca04972975884abad5183292b/crates/rolldown_binding/src/utils/normalize_binding_options.rs#L130
+    resolveId: {
+      filter: {
+        id: {
+          include: [
+            // In most cases, we want all dependencies in library packages to be
+            // externalized. Thus, this regex matches all non-relative imports.
+            nonRelativeSpecifierPattern,
+            // Also include explicitExternalize because those may target relative
+            // paths (e.g. ./draconvert.js in mock-services).
+            ...explicitExternalize
+          ],
+          exclude: bundleIn
+        }
+      },
+      handler(id, importer, resolveOptions) {
+        if (matchesAny(id, externalize)) {
+          return false;
+        }
+        if (
+          // Entrypoints look like src/components/button/button.tsx, so are
+          // matched by the nonRelativeSpecifierPattern
+          resolveOptions.isEntry || // Virtual specifiers are handled by plugins
+          id.startsWith("\0") || // data: node: virtual:
+          id.includes(":") || // ?raw ?url ?worker - resolved by other plugins
+          id.includes("?") || // Applications can bundle in anything
+          options.isApplication === true
+        ) {
+          return;
+        }
+        const error = `[${pluginName}] Vite tried to bundle in "${id}" (imported by ${importer}).
+This is likely undesirable. To externalize it, declare this dependency as a "dependency", "peerDependency" or "optionalDependency" in package.json.
+If this is intentional, add it to the build.dependencies.bundleIn option in useLumina() or bundleIn option in the vitePresetPlugin().
+If this is an application rather than a library, pass isApplication:true in vitePresetPlugin().`;
+        if (isStrictBundling) {
+          throw Error(error);
+        } else {
+          console.error(styleText("red", `${error}
+This will be an error in future version.`));
+          return;
+        }
+      }
+    }
+  };
+  return plugin;
+}
+const pluginName = "@arcgis/node-toolkit:externalize-dependencies";
+const stringToStartsWithGlob = (option) => typeof option === "string" ? new RegExp(
+  `^${option.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&")}${option.endsWith("/") ? "(?:.+)?" : "(?:/.+)?"}$`,
+  "u"
+) : option;
+const nonRelativeSpecifierPattern = /^[^\.\/]/u;
+function matchesAny(id, patterns) {
+  for (let index = 0; index < patterns.length; ++index) {
+    if (patterns[index].test(id)) {
+      return true;
+    }
+  }
+  return false;
+}
+const exportsForTests = {
+  stringToStartsWithGlob,
+  externalizeDependenciesImplementation,
+  matchesAny
+};
+export {
+  exportsForTests,
+  externalizeDependencies
+};

package/dist/vite/installPlaywright.d.ts

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

package/dist/vite/installPlaywright.js

@@ -0,0 +1,87 @@
+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 { pathToFileURL } from "node:url";
+let installPromise;
+function installPlaywright() {
+  return {
+    name: "install-playwright",
+    apply() {
+      if (process.env.VITEST === "true") {
+        installPromise ??= ensureInstalled();
+        return true;
+      }
+      return false;
+    },
+    async configResolved() {
+      await installPromise;
+    }
+  };
+}
+async function ensureInstalled() {
+  const playwrightCwd = findPath("node_modules/playwright");
+  if (playwrightCwd === void 0) {
+    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())) {
+    return;
+  }
+  const home = homedir();
+  const { env, platform } = process;
+  const stateDir = env.XDG_STATE_HOME ?? env.XDG_CACHE_HOME ?? (platform === "win32" ? env.LOCALAPPDATA ?? join(home, "AppData", "Local", "webgis-sdk") : platform === "darwin" ? join(home, "Library", "Caches", "webgis-sdk") : join(home, ".local", "state", "webgis-sdk"));
+  const lockPath = join(stateDir, "playwright-install.lock");
+  await mkdir(stateDir, { recursive: true });
+  const releaseLock = await acquireLock(lockPath);
+  try {
+    if (await existsAsync(chromium.executablePath())) {
+      return;
+    }
+    const installArgs = [
+      join(playwrightCwd, "cli.js"),
+      "install",
+      ...process.platform === "linux" ? ["--with-deps"] : [],
+      "chromium",
+      "chromium-headless-shell"
+    ];
+    await runCommand(process.execPath, installArgs, { stdio: ["ignore", "ignore", "inherit"] });
+  } finally {
+    await releaseLock();
+  }
+}
+const lockPoll = 500;
+async function acquireLock(lockDir) {
+  const startTime = Date.now();
+  while (true) {
+    try {
+      await mkdir(lockDir);
+      return async () => {
+        await rm(lockDir, { recursive: true, force: true }).catch(() => {
+        });
+      };
+    } catch (err) {
+      if (err?.code !== "EEXIST") {
+        throw err;
+      }
+      const lockTimeout = 10 * 60 * 1e3;
+      try {
+        const stats = await stat(lockDir);
+        if (Date.now() - stats.mtimeMs > lockTimeout) {
+          await rm(lockDir, { recursive: true, force: true }).catch(() => {
+          });
+          continue;
+        }
+      } catch {
+      }
+      if (Date.now() - startTime > lockTimeout) {
+        throw new Error(`Timed out waiting for Playwright install lock: ${lockDir}`);
+      }
+      await new Promise((resolve) => setTimeout(resolve, lockPoll));
+    }
+  }
+}
+export {
+  installPlaywright
+};

package/dist/vite/presetPlugin.d.ts

@@ -0,0 +1,21 @@
+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;
+};
+/**
+ * Vite preset for all our support packages:
+ * - externalizes all non-dev-dependencies
+ *
+ * @public
+ * @param options
+ */
+export declare function vitePresetPlugin({ dtsOptions, externalize, bundleIn, isApplication }?: VitePresetOptions): [Plugin, Plugin, Promise<Plugin> | undefined];

package/dist/vite/presetPlugin.js

@@ -0,0 +1,76 @@
+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.");
+}
+function vitePresetPlugin({ dtsOptions = {}, externalize, bundleIn, isApplication } = {
+  externalize: [],
+  dtsOptions: {}
+}) {
+  const dist = `${path.resolve("dist")}/`;
+  const distSrc = `${dist}src/`;
+  let command = void 0;
+  return [
+    {
+      name: "vite-preset-config",
+      config({ build: { target } = {} }, env) {
+        command = env.command;
+        return {
+          build: {
+            // REFACTOR: get this from tsconfig
+            // It's a best practice to let the final bundler down-level as needed.
+            target: target ?? "es2024"
+          },
+          define: env.mode === "test" ? {
+            "process.env.ESRI_INTERNAL": true
+          } : void 0
+        };
+      }
+    },
+    externalizeDependencies({
+      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 {
+  vitePresetPlugin
+};

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;