@arcgis/components-build-utils 5.2.0-next.1 → 5.2.0-next.10

package/dist/index.js

@@ -241,7 +241,6 @@ function vitePresetPlugin({
 }) {
   const dist = `${path.resolve("dist")}/`;
   const distSrc = `${dist}src/`;
-  let userConfig = void 0;
   let command = void 0;
   return [
     {
@@ -258,9 +257,6 @@ function vitePresetPlugin({
             "process.env.ESRI_INTERNAL": true
           } : void 0
         };
-      },
-      configResolved(config) {
-        userConfig = config;
       }
     },
     externalizeDependencies({
@@ -274,20 +270,6 @@ function vitePresetPlugin({
     dtsOptions === false ? void 0 : import("vite-plugin-dts").then(
       ({ default: dts }) => dts({
         logLevel: "warn",
-        // Copies .d.ts files to d.cjs file for CommonJS.
-        // Adds a performance hit as it occurs after the build
-        async afterBuild(emitted) {
-          if (userConfig?.build?.lib && userConfig.build.lib.formats?.includes("cjs")) {
-            await Promise.all(
-              emitted.entries().map(async ([filePath, content]) => {
-                if (filePath.endsWith(".d.ts")) {
-                  await writeFile(filePath.replace(".d.ts", ".d.cts"), content);
-                }
-              })
-            );
-          }
-          await dtsOptions?.afterBuild?.(emitted);
-        },
         ...dtsOptions,
         compilerOptions: {
           rootDir: ".",

package/package.json

@@ -1,18 +1,14 @@
 {
   "name": "@arcgis/components-build-utils",
-  "version": "5.2.0-next.1",
+  "version": "5.2.0-next.10",
   "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",
-  "main": "./dist/index.cjs",
+  "main": "./dist/index.js",
   "module": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "exports": {
-    ".": {
-      "types": "./dist/index.d.ts",
-      "import": "./dist/index.js",
-      "require": "./dist/index.cjs"
-    }
+    ".": "./dist/index.js"
   },
   "files": [
     "dist/"

package/dist/file.d.cts

@@ -1,18 +0,0 @@
-import { ExecSyncOptionsWithStringEncoding, SpawnSyncOptionsWithStringEncoding } from 'node:child_process';
-export declare const existsAsync: (file: string) => Promise<boolean>;
-/** Wrapper for execSync to execute shell commands */
-export declare function sh(command: string, options?: Partial<ExecSyncOptionsWithStringEncoding>): string;
-/** Wrapper for spawnSync to execute commands without shell interpolation. */
-export declare function sp(command: string, args: string[], options?: Partial<SpawnSyncOptionsWithStringEncoding>): string;
-export declare function asyncSh(command: string, options?: Partial<ExecSyncOptionsWithStringEncoding>): Promise<string>;
-export declare function createFileIfNotExists(filePath: string, content: string): Promise<void>;
-/**
- * Climb the directory tree upward, until found a directory that contains the
- * target file, and return resulting full path
- */
-export declare function findPath(target: string, startDirectory?: string): string | undefined;
-/**
- * Climb the directory tree upward, until found a directory that contains the
- * target file, and return resulting full path
- */
-export declare function asyncFindPath(target: string, startDirectory?: string): Promise<string | undefined>;

package/dist/glob.d.cts

@@ -1,24 +0,0 @@
-/**
- * Read `.gitignore` files and convert it to globs that are accepted by ESLint
- *
- * @example
- * ```ts
- * // eslint.config.js
- * import { gitIgnoreFileToGlobs } from "@arcgis/components-build-utils";
- * import { globalIgnores } from "eslint/config";
- *
- * export default [
- *   globalIgnores([
- *     ...gitIgnoreFileToGlobs(import.meta.dirname + "/.gitignore"),
- *     ...gitIgnoreFileToGlobs(import.meta.dirname + "/.prettierignore"),
- *   ]),
- *   // ...
- * ];
- * ```
- */
-export declare function gitIgnoreFileToGlobs(filePath: string): string[];
-/**
- * @deprecated Use gitIgnoreFileToGlobs from "@arcgis/components-build-utils"
- * instead
- */
-export declare const gitIgnoreToGlob: (pattern: string) => string;

package/dist/index.cjs

@@ -1,464 +0,0 @@
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const node_fs = require("node:fs");
-const promises = require("node:fs/promises");
-const path$1 = require("path");
-const node_url = require("node:url");
-const node_child_process = require("node:child_process");
-const node_util = require("node:util");
-const node_module = require("node:module");
-const existsAsync = async (file) => (
-  // Using un-promisified version because promises version creates exceptions
-  // which interferes with debugging when "Pause on caught exceptions" is enabled
-  await new Promise((resolve2) => node_fs.access(file, promises.constants.F_OK, (error) => resolve2(!error)))
-);
-function sh(command, options = {}) {
-  try {
-    const normalizedOptions = { encoding: "utf8", ...options };
-    return node_child_process.execSync(command.trim(), normalizedOptions).trim();
-  } catch (error) {
-    makeExecErrorReadable(error);
-    throw error;
-  }
-}
-function sp(command, args, options = {}) {
-  const normalizedOptions = { encoding: "utf8", ...options };
-  const result = node_child_process.spawnSync(command, args, normalizedOptions);
-  if (result.error) {
-    throw result.error;
-  }
-  const output = `${result.stdout ?? ""}${result.stderr ?? ""}`.trim();
-  const exitCode = result.status ?? 0;
-  if (exitCode !== 0) {
-    throw new Error(
-      `Command failed with exit code ${String(exitCode)}: ${command} ${args.join(" ")}
-${output}`.trim()
-    );
-  }
-  return output;
-}
-async function asyncSh(command, options = {}) {
-  const normalizedOptions = { encoding: "utf8", ...options };
-  return await new Promise((resolve2, reject) => {
-    node_child_process.exec(command.trim(), normalizedOptions, (error, stdout, stderr) => {
-      if (error) {
-        makeExecErrorReadable(error);
-        reject(error);
-        return;
-      }
-      resolve2(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 = `${node_util.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 }
-    });
-  }
-}
-async function createFileIfNotExists(filePath, content) {
-  await promises.mkdir(path$1.dirname(filePath), { recursive: true });
-  if (!await existsAsync(filePath)) {
-    await promises.writeFile(filePath, content, { encoding: "utf8" });
-  }
-}
-function findPath(target, startDirectory = process.cwd()) {
-  const resolvedStartDirectory = startDirectory.startsWith("file:///") ? path$1.dirname(node_url.fileURLToPath(startDirectory)) : path$1.resolve(startDirectory);
-  const parentPath = resolvedStartDirectory.split(path$1.sep);
-  while (parentPath.length > searchStopIndex) {
-    const fullPath = path$1.join(
-      ...path$1.sep === "/" ? ["/"] : [],
-      ...parentPath,
-      target
-    );
-    if (node_fs.existsSync(fullPath)) {
-      return fullPath;
-    }
-    parentPath.pop();
-  }
-  return void 0;
-}
-const searchStopIndex = 0;
-async function asyncFindPath(target, startDirectory = process.cwd()) {
-  const resolvedStartDirectory = startDirectory.startsWith("file:///") ? path$1.dirname(node_url.fileURLToPath(startDirectory)) : path$1.resolve(startDirectory);
-  const parentPath = resolvedStartDirectory.split(path$1.sep);
-  while (parentPath.length > searchStopIndex) {
-    const fullPath = path$1.join(
-      ...path$1.sep === "/" ? ["/"] : [],
-      ...parentPath,
-      target
-    );
-    if (await existsAsync(fullPath)) {
-      return fullPath;
-    }
-    parentPath.pop();
-  }
-  return void 0;
-}
-function gitIgnoreFileToGlobs(filePath) {
-  return node_fs.readFileSync(filePath, "utf8").split("\n").filter((line) => line.trim().length > 0 && !line.trim().startsWith("#")).map(gitIgnoreToGlob);
-}
-const gitIgnoreToGlob = (pattern) => fixAbsoluteSyntax(fixMatchFilesSyntax(pattern));
-function fixAbsoluteSyntax(pattern) {
-  if (pattern.startsWith("/")) {
-    return pattern.slice(1);
-  }
-  if (pattern.startsWith("!/")) {
-    return `!${pattern.slice(2)}`;
-  }
-  const isAlreadyCorrect = pattern.startsWith("**") || pattern.startsWith("!**");
-  const basePattern = pattern.startsWith("!") ? pattern.slice(1) : pattern;
-  return isAlreadyCorrect ? pattern : `${pattern.startsWith("!") ? "!" : ""}**/${basePattern}`;
-}
-function fixMatchFilesSyntax(pattern) {
-  const base = pattern.split("/").at(-1);
-  const isAlreadyCorrect = pattern.endsWith("**") || pattern.includes("{") || base?.includes(".");
-  if (isAlreadyCorrect) {
-    return pattern;
-  }
-  return pattern.endsWith("/*") ? `${pattern}*` : pattern.endsWith("/") ? `${pattern}**` : `${pattern}/**`;
-}
-const isPosix = path$1.sep === path$1.posix.sep;
-const toPosixPathSeparators = (relativePath) => relativePath.includes(path$1.win32.sep) ? relativePath.replaceAll(path$1.win32.sep, path$1.posix.sep) : relativePath;
-const normalizePath = isPosix ? (path2) => path2 : toPosixPathSeparators;
-const toWin32PathSeparators = (relativePath) => relativePath.includes(path$1.posix.sep) ? relativePath.replaceAll(path$1.posix.sep, path$1.win32.sep) : relativePath;
-const toSystemPathSeparators = isPosix ? (path2) => path2 : toWin32PathSeparators;
-const getCwd = isPosix ? process.cwd : () => toPosixPathSeparators(process.cwd());
-const path = isPosix ? path$1.posix : {
-  ...path$1.win32,
-  sep: path$1.posix.sep,
-  join(...paths) {
-    const result = path$1.win32.join(...paths);
-    return toPosixPathSeparators(result);
-  },
-  normalize(path2) {
-    const result = path$1.win32.normalize(path2);
-    return toPosixPathSeparators(result);
-  },
-  relative(from, to) {
-    const result = path$1.win32.relative(from, to);
-    return toPosixPathSeparators(result);
-  },
-  dirname(path2) {
-    const result = path$1.win32.dirname(path2);
-    return toPosixPathSeparators(result);
-  },
-  resolve(...paths) {
-    const result = path$1.win32.resolve(...paths);
-    return toPosixPathSeparators(result);
-  },
-  toNamespacedPath(path2) {
-    const result = path$1.win32.toNamespacedPath(path2);
-    return toPosixPathSeparators(result);
-  }
-};
-const cachedPackageJson = {};
-const cachedPackageJsonPromises = {};
-let rootPackageJsonLocation;
-function retrievePackageJson(location, cache = true) {
-  const packageJsonPath = location ? path.resolve(location, "package.json") : rootPackageJsonLocation ??= findPath("package.json");
-  if (cache) {
-    cachedPackageJson[packageJsonPath] ??= JSON.parse(node_fs.readFileSync(packageJsonPath, "utf-8"));
-    return cachedPackageJson[packageJsonPath];
-  }
-  return JSON.parse(node_fs.readFileSync(packageJsonPath, "utf-8"));
-}
-async function asyncRetrievePackageJson(location) {
-  const packageJsonPath = location ? path.resolve(location, "package.json") : rootPackageJsonLocation ??= findPath("package.json");
-  if (packageJsonPath in cachedPackageJson) {
-    return cachedPackageJson[packageJsonPath];
-  }
-  cachedPackageJsonPromises[packageJsonPath] ??= asyncReadPackageJson(packageJsonPath);
-  const result = await cachedPackageJsonPromises[packageJsonPath];
-  cachedPackageJson[packageJsonPath] ??= result;
-  return result;
-}
-const asyncReadPackageJson = async (location) => JSON.parse(await promises.readFile(location, "utf-8"));
-const cachedPackageLocation = {};
-const cachedPackageLocationPromises = {};
-async function fetchPackageLocation(packageName, cwd) {
-  if (packageName in cachedPackageLocation) {
-    return cachedPackageLocation[packageName];
-  }
-  cachedPackageLocationPromises[packageName] ??= asyncFindPath(
-    path.join("node_modules", packageName, "package.json"),
-    cwd
-  ).then((packageJsonLocation) => {
-    if (packageJsonLocation === void 0) {
-      throw Error(
-        `@arcgis/components-build-utils: Unable to resolve package.json location for "${packageName}" package. Current working directory: ${process.cwd()}`
-      );
-    }
-    return path.dirname(packageJsonLocation);
-  });
-  const result = await cachedPackageLocationPromises[packageName];
-  cachedPackageLocation[packageName] ??= result;
-  return cachedPackageLocation[packageName];
-}
-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 (!node_fs.existsSync(packageJson)) {
-        continue;
-      }
-      const contents = JSON.parse(node_fs.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;
-}
-function vitePresetPlugin({
-  dtsOptions = {},
-  externalize,
-  bundleIn,
-  isApplication
-} = {
-  externalize: [],
-  dtsOptions: {}
-}) {
-  const dist = `${path.resolve("dist")}/`;
-  const distSrc = `${dist}src/`;
-  let userConfig = void 0;
-  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
-        };
-      },
-      configResolved(config) {
-        userConfig = config;
-      }
-    },
-    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",
-        // Copies .d.ts files to d.cjs file for CommonJS.
-        // Adds a performance hit as it occurs after the build
-        async afterBuild(emitted) {
-          if (userConfig?.build?.lib && userConfig.build.lib.formats?.includes("cjs")) {
-            await Promise.all(
-              emitted.entries().map(async ([filePath, content]) => {
-                if (filePath.endsWith(".d.ts")) {
-                  await promises.writeFile(filePath.replace(".d.ts", ".d.cts"), content);
-                }
-              })
-            );
-          }
-          await dtsOptions?.afterBuild?.(emitted);
-        },
-        ...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 baseBeforeWriteFile = dtsOptions?.beforeWriteFile ?? ((filePath2, content2) => ({ filePath: filePath2, content: content2 }));
-            return await baseBeforeWriteFile(`${dist}${filePath.slice(distSrc.length)}`, 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);
-        }
-      })
-    )
-  ];
-}
-function shouldSkip(id) {
-  return id.includes("__test") || id.includes(".e2e.") || id.includes(".spec.") || id.includes(".test.") || id.includes(".stories.");
-}
-function externalizeDependencies(options) {
-  return externalizeDependenciesImplementation(options, retrievePackageJson());
-}
-function externalizeDependenciesImplementation(options, packageJson) {
-  const externalDependencies = Object.keys({
-    ...packageJson.dependencies,
-    ...packageJson.peerDependencies,
-    ...packageJson.optionalDependencies
-  });
-  const isStrictBundling = toPosixPathSeparators(void 0).includes(
-    "support-packages/components-build-utils"
-  );
-  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 ? "" : "|"}${node_module.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(node_util.styleText("red", `${error}
-This will be an error in future version.`));
-          return;
-        }
-      }
-    }
-  };
-  return plugin;
-}
-const pluginName = "@arcgis/components-build-utils: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;
-}
-exports.asyncFindPath = asyncFindPath;
-exports.asyncRetrievePackageJson = asyncRetrievePackageJson;
-exports.asyncSh = asyncSh;
-exports.createFileIfNotExists = createFileIfNotExists;
-exports.detectPackageManager = detectPackageManager;
-exports.existsAsync = existsAsync;
-exports.externalizeDependencies = externalizeDependencies;
-exports.fetchPackageLocation = fetchPackageLocation;
-exports.findPath = findPath;
-exports.getCwd = getCwd;
-exports.gitIgnoreFileToGlobs = gitIgnoreFileToGlobs;
-exports.gitIgnoreToGlob = gitIgnoreToGlob;
-exports.isPosix = isPosix;
-exports.normalizePath = normalizePath;
-exports.path = path;
-exports.retrievePackageJson = retrievePackageJson;
-exports.sh = sh;
-exports.sp = sp;
-exports.toPosixPathSeparators = toPosixPathSeparators;
-exports.toSystemPathSeparators = toSystemPathSeparators;
-exports.vitePresetPlugin = vitePresetPlugin;

package/dist/index.d.cts

@@ -1,5 +0,0 @@
-export { existsAsync, sh, sp, asyncSh, createFileIfNotExists, findPath, asyncFindPath } from './file.ts';
-export { gitIgnoreFileToGlobs, gitIgnoreToGlob } from './glob.ts';
-export { isPosix, toPosixPathSeparators, normalizePath, toSystemPathSeparators, getCwd, path } from './path.ts';
-export { type PackageJson, retrievePackageJson, asyncRetrievePackageJson, fetchPackageLocation, detectPackageManager, } from './packageJson.ts';
-export { vitePresetPlugin, type DependencyManagementOptions, externalizeDependencies } from './vite.ts';

package/dist/packageJson.d.cts

@@ -1,43 +0,0 @@
-/**
- * A subset of the package.json typing that is interesting to Lumina.
- *
- * The full package.json type is insanely large (20k lines):
- * https://github.com/ffflorian/schemastore-updater/blob/main/schemas/package/index.d.ts#L20067
- */
-export type PackageJson = {
-    "name": string;
-    "version": string;
-    "private"?: boolean;
-    "type"?: "commonjs" | "module";
-    "main"?: string;
-    "module"?: string;
-    "types"?: string;
-    "files"?: string[];
-    "bin"?: Record<string, string> | string;
-    "man"?: string[] | string;
-    "dependencies"?: Record<string, string>;
-    "devDependencies"?: Record<string, string>;
-    "peerDependencies"?: Record<string, string>;
-    "peerDependenciesMeta"?: Record<string, {
-        optional?: boolean;
-    }>;
-    "optionalDependencies"?: Record<string, string>;
-    "css.customData"?: string[];
-    "customElements"?: string;
-    "html.customData"?: string[];
-    "web-types"?: string;
-    "exports"?: Record<string, Record<string, string> | string>;
-    "scripts"?: Record<string, string>;
-    "packageManager"?: string;
-};
-export declare function retrievePackageJson(location?: string, cache?: boolean): PackageJson;
-export declare function asyncRetrievePackageJson(location?: string): Promise<PackageJson>;
-/**
- * Returns an absolute path to the root of a package in node_modules, without
- * trailing slash.
- */
-export declare function fetchPackageLocation(packageName: string, cwd?: string): Promise<string>;
-/**
- * Detect if current repository/monorepo uses npm, pnpm, or yarn
- */
-export declare function detectPackageManager(cwd?: string): string;

package/dist/path.d.cts

@@ -1,30 +0,0 @@
-import { posix } from 'path';
-/**
- * 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)
- */
-export declare const isPosix: boolean;
-export declare const toPosixPathSeparators: (relativePath: string) => string;
-export declare const normalizePath: (relativePath: string) => string;
-/**
- * On Windows, replace all `/` in the path back with `\\`. Do this only if you
- * 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).
- */
-export declare const toSystemPathSeparators: (relativePath: string) => string;
-/**
- * Like `process.cwd()`, but always returns a POSIX-style path
- * (with `/` as separator).
- */
-export declare const getCwd: () => string;
-/**
- * A wrapper for Node.js's `path` module that always uses POSIX-style paths
- * (with `/` as separator).
- */
-export declare const path: typeof posix & {
-    sep: "/";
-};
-export declare const exportsForTests: {
-    toWin32PathSeparators: (relativePath: string) => string;
-};

package/dist/vite.d.cts

@@ -1,101 +0,0 @@
-import { Plugin } from 'vite';
-import { default as dts } from 'vite-plugin-dts';
-import { PackageJson } from './packageJson.ts';
-/**
- * Vite preset for all our support packages:
- * - externalizes all non-dev-dependencies
- * - generates type declarations (using `vite-plugin-dts`)
- */
-export declare function vitePresetPlugin({ dtsOptions, externalize, bundleIn, isApplication, }?: DependencyManagementOptions & {
-    /** Additional options for `vite-plugin-dts` */
-    dtsOptions?: Parameters<typeof dts>[0] | false;
-}): [Plugin, Plugin, Promise<Plugin> | undefined];
-/**
- * Options for externalizing dependencies.
- */
-export type DependencyManagementOptions = {
-    /**
-     * Force bundle in these dependencies even if they are declared as
-     * dependencies or peerDependencies.
-     *
-     * @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.
-     *
-     * @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.
-     *
-     * @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.
- *
- * @see {@link ./buildCdn.ts} for CDN dependency bundling details
- *
- * @remarks
- * If a dependency is both a peerDependency and a devDependency, it will still
- * be externalized (because all peerDependencies are externalized).
- */
-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 {};