create-yoya-ui 0.2.2 → 0.2.3

package/templates/admin/node_modules/rolldown/dist/experimental-runtime.d.ts

@@ -1,177 +0,0 @@
-/**
- * Compiler-emitted module-graph delta — pure topology (static + dynamic edges).
- * `ids[0, localCount)` are the modules this payload carries; `ids[localCount, …)` are foreign edge targets.
- * `edges[i]` / `dynamicEdges[i]` are the static / dynamic-`import()` out-edges of `ids[i]`.
- * @typedef {{ ids: string[], localCount: number, edges: number[][], dynamicEdges?: number[][] }} ModuleGraphDelta
- * @typedef {{ createModuleHotContext(moduleId: string): any, onModuleCacheRemoval(moduleId: string): void }} DevRuntimeHooks
- */
-export class MissingFactoryError {
-    /**
-     * @param {string} id
-     */
-    constructor(id: string);
-    id: string;
-}
-export class DevRuntime {
-    /**
-     * @param {string} clientId
-     */
-    constructor(clientId: string);
-    /**
-     * Client ID generated at runtime initialization, used for lazy compilation requests.
-     * @type {string}
-     */
-    clientId: string;
-    /**
-     * Static import edges from `registerGraph` — entries persist across `removeModuleCache`
-     * and change only by replacement from a newer payload (last write wins).
-     * @type {Map<string, { edges: string[] }>}
-     */
-    staticImports: Map<string, {
-        edges: string[];
-    }>;
-    /**
-     * Reverse index over the static imports.
-     * @type {Map<string, Set<string>>}
-     */
-    importers: Map<string, Set<string>>;
-    /**
-     * Dynamic `import()` edges from `registerGraph`, keyed by importer — mirror of
-     * `staticImports` for the dynamic reverse index.
-     * @type {Map<string, { edges: string[] }>}
-     */
-    dynamicImports: Map<string, {
-        edges: string[];
-    }>;
-    /**
-     * Reverse index over the dynamic imports.
-     * @type {Map<string, Set<string>>}
-     */
-    dynamicImporters: Map<string, Set<string>>;
-    /**
-     * The module cache. Membership means "this module's side effects ran in this tab" —
-     * registration is emitted ahead of every module body, and nothing un-registers on
-     * unwind, so a factory that throws mid-body stays registered. A `Map` rather than a
-     * plain object: HMR eviction deletes entries, and a `delete` on an object drops V8
-     * into dictionary mode, taxing every later lookup on the hottest read path.
-     * @type {Map<string, Module>}
-     */
-    moduleCache: Map<string, Module>;
-    /**
-     * Re-runnable factories from HMR patches and lazy chunks. The initial bundle stays
-     * scope-hoisted and contributes none.
-     * @type {Map<string, { kind: 'esm' | 'cjs', fn: (id: string) => void }>}
-     */
-    factories: Map<string, {
-        kind: "esm" | "cjs";
-        fn: (id: string) => void;
-    }>;
-    /**
-     * Installed by the dev client at boot. The runtime is a store + executor and makes
-     * no HMR decisions; accepting, disposing, and reloading live behind these hooks.
-     * @type {DevRuntimeHooks | null}
-     */
-    hooks: DevRuntimeHooks | null;
-    /**
-     * @param {ModuleGraphDelta} delta
-     */
-    registerGraph(delta: ModuleGraphDelta): void;
-    /**
-     * @param {string} id
-     * @param {'esm' | 'cjs'} kind
-     * @param {(id: string) => void} fn
-     */
-    registerFactory(id: string, kind: "esm" | "cjs", fn: (id: string) => void): void;
-    /**
-     * @param {string} id
-     * @param {{ exports: any }} [exportsHolder]
-     */
-    registerModule(id: string, exportsHolder?: {
-        exports: any;
-    }): void;
-    /**
-     * @param {string} id
-     * @returns {string[]}
-     */
-    getImporters(id: string): string[];
-    /**
-     * @param {string} id
-     */
-    isExecuted(id: string): any;
-    /**
-     * @param {string} id
-     */
-    hasFactory(id: string): any;
-    /**
-     * Module-cache delete only — static imports and factories persist. Removal is what
-     * re-arms a cache-gated factory for `initModule`.
-     * @param {string} id
-     */
-    removeModuleCache(id: string): void;
-    /**
-     * The one re-execution gate: registered → return the live exports; otherwise run the
-     * mapped factory (which registers itself first, then runs the body).
-     * @param {string} id
-     */
-    initModule(id: string): any;
-    /**
-     * @param {string} id
-     */
-    loadExports(id: string): any;
-    /**
-     * @param {string} moduleId
-     */
-    createModuleHotContext(moduleId: string): any;
-    /** @internal */
-    __toESM: any;
-    /** @internal */
-    __toCommonJS: any;
-    /** @internal */
-    __exportAll: any;
-    /**
-     * @param {boolean} [isNodeMode]
-     * @returns {(mod: any) => any}
-     * @internal
-     */
-    __toDynamicImportESM: (isNodeMode?: boolean) => (mod: any) => any;
-    /** @internal */
-    __reExport: any;
-}
-/**
- * Compiler-emitted module-graph delta — pure topology (static + dynamic edges).
- * `ids[0, localCount)` are the modules this payload carries; `ids[localCount, …)` are foreign edge targets.
- * `edges[i]` / `dynamicEdges[i]` are the static / dynamic-`import()` out-edges of `ids[i]`.
- */
-export type ModuleGraphDelta = {
-    ids: string[];
-    localCount: number;
-    edges: number[][];
-    dynamicEdges?: number[][];
-};
-/**
- * Compiler-emitted module-graph delta — pure topology (static + dynamic edges).
- * `ids[0, localCount)` are the modules this payload carries; `ids[localCount, …)` are foreign edge targets.
- * `edges[i]` / `dynamicEdges[i]` are the static / dynamic-`import()` out-edges of `ids[i]`.
- */
-export type DevRuntimeHooks = {
-    createModuleHotContext(moduleId: string): any;
-    onModuleCacheRemoval(moduleId: string): void;
-};
-declare class Module {
-    /**
-     * @param {string} id
-     */
-    constructor(id: string);
-    /**
-     * @type {{ exports: any }}
-     */
-    exportsHolder: {
-        exports: any;
-    };
-    /**
-     * @type {string}
-     */
-    id: string;
-    get exports(): any;
-}
-export {};

package/templates/admin/node_modules/rolldown/dist/experimental-runtime.mjs

@@ -1,257 +0,0 @@
-import { __exportAll, __reExport, __toCommonJS, __toESM } from './experimental-runtime-base.mjs';
-// @ts-check
-
-class Module {
-  /**
-   * @type {{ exports: any }}
-   */
-  exportsHolder = { exports: null };
-  /**
-   * @type {string}
-   */
-  id;
-
-  /**
-   * @param {string} id
-   */
-  constructor(id) {
-    this.id = id;
-  }
-
-  get exports() {
-    return this.exportsHolder.exports;
-  }
-}
-
-/**
- * Compiler-emitted module-graph delta — pure topology (static + dynamic edges).
- * `ids[0, localCount)` are the modules this payload carries; `ids[localCount, …)` are foreign edge targets.
- * `edges[i]` / `dynamicEdges[i]` are the static / dynamic-`import()` out-edges of `ids[i]`.
- * @typedef {{ ids: string[], localCount: number, edges: number[][], dynamicEdges?: number[][] }} ModuleGraphDelta
- * @typedef {{ createModuleHotContext(moduleId: string): any, onModuleCacheRemoval(moduleId: string): void }} DevRuntimeHooks
- */
-
-export class MissingFactoryError extends Error {
-  /**
-   * @param {string} id
-   */
-  constructor(id) {
-    super(`No factory registered for module ${id}`);
-    this.id = id;
-  }
-}
-
-export class DevRuntime {
-  /**
-   * Client ID generated at runtime initialization, used for lazy compilation requests.
-   * @type {string}
-   */
-  clientId;
-
-  /**
-   * @param {string} clientId
-   */
-  constructor(clientId) {
-    this.clientId = clientId;
-  }
-
-  /**
-   * Static import edges from `registerGraph` — entries persist across `removeModuleCache`
-   * and change only by replacement from a newer payload (last write wins).
-   * @type {Map<string, { edges: string[] }>}
-   */
-  staticImports = new Map();
-  /**
-   * Reverse index over the static imports.
-   * @type {Map<string, Set<string>>}
-   */
-  importers = new Map();
-  /**
-   * Dynamic `import()` edges from `registerGraph`, keyed by importer — mirror of
-   * `staticImports` for the dynamic reverse index.
-   * @type {Map<string, { edges: string[] }>}
-   */
-  dynamicImports = new Map();
-  /**
-   * Reverse index over the dynamic imports.
-   * @type {Map<string, Set<string>>}
-   */
-  dynamicImporters = new Map();
-  /**
-   * The module cache. Membership means "this module's side effects ran in this tab" —
-   * registration is emitted ahead of every module body, and nothing un-registers on
-   * unwind, so a factory that throws mid-body stays registered. A `Map` rather than a
-   * plain object: HMR eviction deletes entries, and a `delete` on an object drops V8
-   * into dictionary mode, taxing every later lookup on the hottest read path.
-   * @type {Map<string, Module>}
-   */
-  moduleCache = new Map();
-  /**
-   * Re-runnable factories from HMR patches and lazy chunks. The initial bundle stays
-   * scope-hoisted and contributes none.
-   * @type {Map<string, { kind: 'esm' | 'cjs', fn: (id: string) => void }>}
-   */
-  factories = new Map();
-  /**
-   * Installed by the dev client at boot. The runtime is a store + executor and makes
-   * no HMR decisions; accepting, disposing, and reloading live behind these hooks.
-   * @type {DevRuntimeHooks | null}
-   */
-  hooks = null;
-
-  /**
-   * @param {ModuleGraphDelta} delta
-   */
-  registerGraph(delta) {
-    for (let i = 0; i < delta.localCount; i++) {
-      const id = delta.ids[i];
-      const edges = delta.edges[i].map((j) => delta.ids[j]);
-      for (const target of this.staticImports.get(id)?.edges ?? []) {
-        this.importers.get(target)?.delete(id);
-      }
-      for (const target of edges) {
-        let importerSet = this.importers.get(target);
-        if (!importerSet) {
-          importerSet = new Set();
-          this.importers.set(target, importerSet);
-        }
-        importerSet.add(id);
-      }
-      this.staticImports.set(id, { edges });
-
-      // Dynamic `import()` edges are maintained in a parallel reverse index with the same
-      // last-write-wins bookkeeping; `getImporters` unions the two.
-      const dynamicEdges = (delta.dynamicEdges?.[i] ?? []).map((j) => delta.ids[j]);
-      for (const target of this.dynamicImports.get(id)?.edges ?? []) {
-        this.dynamicImporters.get(target)?.delete(id);
-      }
-      for (const target of dynamicEdges) {
-        let importerSet = this.dynamicImporters.get(target);
-        if (!importerSet) {
-          importerSet = new Set();
-          this.dynamicImporters.set(target, importerSet);
-        }
-        importerSet.add(id);
-      }
-      this.dynamicImports.set(id, { edges: dynamicEdges });
-    }
-  }
-
-  /**
-   * @param {string} id
-   * @param {'esm' | 'cjs'} kind
-   * @param {(id: string) => void} fn
-   */
-  registerFactory(id, kind, fn) {
-    this.factories.set(id, { kind, fn });
-  }
-
-  /**
-   * @param {string} id
-   * @param {{ exports: any }} [exportsHolder]
-   */
-  registerModule(id, exportsHolder = { exports: {} }) {
-    const module = new Module(id);
-    module.exportsHolder = exportsHolder;
-    this.moduleCache.set(id, module);
-  }
-
-  /**
-   * @param {string} id
-   * @returns {string[]}
-   */
-  getImporters(id) {
-    // Static ∪ dynamic importers — the boundary walk treats both kinds the same (parity
-    // with Vite `node.importers` / webpack `module.parents`). Deduped so a module that
-    // imports `id` both statically and via `import()` appears once.
-    const dynamic = this.dynamicImporters.get(id);
-    if (!dynamic || dynamic.size === 0) {
-      return [...(this.importers.get(id) ?? [])];
-    }
-    return [...new Set([...(this.importers.get(id) ?? []), ...dynamic])];
-  }
-
-  /**
-   * @param {string} id
-   */
-  isExecuted(id) {
-    return this.moduleCache.has(id);
-  }
-
-  /**
-   * @param {string} id
-   */
-  hasFactory(id) {
-    return this.factories.has(id);
-  }
-
-  /**
-   * Module-cache delete only — static imports and factories persist. Removal is what
-   * re-arms a cache-gated factory for `initModule`.
-   * @param {string} id
-   */
-  removeModuleCache(id) {
-    this.moduleCache.delete(id);
-    this.hooks?.onModuleCacheRemoval(id);
-  }
-
-  /**
-   * The one re-execution gate: registered → return the live exports; otherwise run the
-   * mapped factory (which registers itself first, then runs the body).
-   * @param {string} id
-   */
-  initModule(id) {
-    if (this.moduleCache.has(id)) {
-      return this.loadExports(id);
-    }
-    const factory = this.factories.get(id);
-    if (!factory) {
-      throw new MissingFactoryError(id);
-    }
-    factory.fn(id);
-    return this.loadExports(id);
-  }
-
-  /**
-   * @param {string} id
-   */
-  loadExports(id) {
-    const module = this.moduleCache.get(id);
-    if (module) {
-      return module.exportsHolder.exports;
-    } else {
-      console.warn(`Module ${id} not found`);
-      return {};
-    }
-  }
-
-  /**
-   * @param {string} moduleId
-   */
-  createModuleHotContext(moduleId) {
-    if (this.hooks) {
-      return this.hooks.createModuleHotContext(moduleId);
-    }
-    throw new Error('createModuleHotContext requires installed hooks or an override');
-  }
-
-  /** @internal */
-  // @ts-expect-error The variable will be injected at build time.
-  __toESM = __toESM;
-  /** @internal */
-  // @ts-expect-error The variable will be injected at build time.
-  __toCommonJS = __toCommonJS;
-  /** @internal */
-  // @ts-expect-error The variable will be injected at build time.
-  __exportAll = __exportAll;
-  /**
-   * @param {boolean} [isNodeMode]
-   * @returns {(mod: any) => any}
-   * @internal
-   */
-  // @ts-expect-error The variable will be injected at build time.
-  __toDynamicImportESM = (isNodeMode) => (mod) => __toESM(mod.default, isNodeMode);
-  /** @internal */
-  // @ts-expect-error The variable will be injected at build time.
-  __reExport = __reExport;
-}

package/templates/admin/node_modules/rolldown/dist/filter-index.d.mts

@@ -1,196 +0,0 @@
-import { F as withFilter } from "./shared/define-config-Nbz-lniw.mjs";
-//#region ../../node_modules/.pnpm/@rolldown+pluginutils@1.0.1/node_modules/@rolldown/pluginutils/dist/filter/index.d.mts
-//#region src/filter/composable-filters.d.ts
-type StringOrRegExp = string | RegExp;
-type PluginModuleType = 'js' | 'jsx' | 'ts' | 'tsx' | 'json' | 'text' | 'base64' | 'dataurl' | 'binary' | 'empty' | (string & {});
-type FilterExpressionKind = FilterExpression['kind'];
-type FilterExpression = And | Or | Not | Id | ImporterId | ModuleType | Code | Query;
-type TopLevelFilterExpression = Include | Exclude;
-declare class And {
-  kind: 'and';
-  args: FilterExpression[];
-  constructor(...args: FilterExpression[]);
-}
-declare class Or {
-  kind: 'or';
-  args: FilterExpression[];
-  constructor(...args: FilterExpression[]);
-}
-declare class Not {
-  kind: 'not';
-  expr: FilterExpression;
-  constructor(expr: FilterExpression);
-}
-interface QueryFilterObject {
-  [key: string]: StringOrRegExp | boolean;
-}
-interface IdParams {
-  cleanUrl?: boolean;
-}
-declare class Id {
-  kind: 'id';
-  pattern: StringOrRegExp;
-  params: IdParams;
-  constructor(pattern: StringOrRegExp, params?: IdParams);
-}
-declare class ImporterId {
-  kind: 'importerId';
-  pattern: StringOrRegExp;
-  params: IdParams;
-  constructor(pattern: StringOrRegExp, params?: IdParams);
-}
-declare class ModuleType {
-  kind: 'moduleType';
-  pattern: PluginModuleType;
-  constructor(pattern: PluginModuleType);
-}
-declare class Code {
-  kind: 'code';
-  pattern: StringOrRegExp;
-  constructor(expr: StringOrRegExp);
-}
-declare class Query {
-  kind: 'query';
-  key: string;
-  pattern: StringOrRegExp | boolean;
-  constructor(key: string, pattern: StringOrRegExp | boolean);
-}
-declare class Include {
-  kind: 'include';
-  expr: FilterExpression;
-  constructor(expr: FilterExpression);
-}
-declare class Exclude {
-  kind: 'exclude';
-  expr: FilterExpression;
-  constructor(expr: FilterExpression);
-}
-declare function and(...args: FilterExpression[]): And;
-declare function or(...args: FilterExpression[]): Or;
-declare function not(expr: FilterExpression): Not;
-declare function id(pattern: StringOrRegExp, params?: IdParams): Id;
-declare function importerId(pattern: StringOrRegExp, params?: IdParams): ImporterId;
-declare function moduleType(pattern: PluginModuleType): ModuleType;
-declare function code(pattern: StringOrRegExp): Code;
-declare function query(key: string, pattern: StringOrRegExp | boolean): Query;
-declare function include(expr: FilterExpression): Include;
-declare function exclude(expr: FilterExpression): Exclude;
-/**
- * convert a queryObject to FilterExpression like
- * ```js
- *   and(query(k1, v1), query(k2, v2))
- * ```
- * @param queryFilterObject The query filter object needs to be matched.
- * @returns a `And` FilterExpression
- */
-declare function queries(queryFilter: QueryFilterObject): And;
-declare function interpreter(exprs: TopLevelFilterExpression | TopLevelFilterExpression[], code?: string, id?: string, moduleType?: PluginModuleType, importerId?: string): boolean;
-interface InterpreterCtx {
-  urlSearchParamsCache?: URLSearchParams;
-}
-declare function interpreterImpl(expr: TopLevelFilterExpression[], code?: string, id?: string, moduleType?: PluginModuleType, importerId?: string, ctx?: InterpreterCtx): boolean;
-declare function exprInterpreter(expr: FilterExpression, code?: string, id?: string, moduleType?: PluginModuleType, importerId?: string, ctx?: InterpreterCtx): boolean;
-//#endregion
-//#region src/filter/filter-vite-plugins.d.ts
-/**
- * Filters out Vite plugins that have `apply: 'serve'` set.
- *
- * Since Rolldown operates in build mode, plugins marked with `apply: 'serve'`
- * are intended only for Vite's dev server and should be excluded from the build process.
- *
- * @param plugins - Array of plugins (can include nested arrays)
- * @returns Filtered array with serve-only plugins removed
- *
- * @example
- * ```ts
- * import { defineConfig } from 'rolldown';
- * import { filterVitePlugins } from '@rolldown/pluginutils';
- * import viteReact from '@vitejs/plugin-react';
- *
- * export default defineConfig({
- *   plugins: filterVitePlugins([
- *     viteReact(),
- *     {
- *       name: 'dev-only',
- *       apply: 'serve', // This will be filtered out
- *       // ...
- *     }
- *   ])
- * });
- * ```
- */
-declare function filterVitePlugins<T = any>(plugins: T | T[] | null | undefined | false): T[];
-//#endregion
-//#region src/filter/simple-filters.d.ts
-/**
- * Constructs a RegExp that matches the exact string specified.
- *
- * This is useful for plugin hook filters.
- *
- * @param str the string to match.
- * @param flags flags for the RegExp.
- *
- * @example
- * ```ts
- * import { exactRegex } from '@rolldown/pluginutils';
- * const plugin = {
- *   name: 'plugin',
- *   resolveId: {
- *     filter: { id: exactRegex('foo') },
- *     handler(id) {} // will only be called for `foo`
- *   }
- * }
- * ```
- */
-declare function exactRegex(str: string, flags?: string): RegExp;
-/**
- * Constructs a RegExp that matches a value that has the specified prefix.
- *
- * This is useful for plugin hook filters.
- *
- * @param str the string to match.
- * @param flags flags for the RegExp.
- *
- * @example
- * ```ts
- * import { prefixRegex } from '@rolldown/pluginutils';
- * const plugin = {
- *   name: 'plugin',
- *   resolveId: {
- *     filter: { id: prefixRegex('foo') },
- *     handler(id) {} // will only be called for IDs starting with `foo`
- *   }
- * }
- * ```
- */
-declare function prefixRegex(str: string, flags?: string): RegExp;
-type WidenString<T> = T extends string ? string : T;
-/**
- * Converts a id filter to match with an id with a query.
- *
- * @param input the id filters to convert.
- *
- * @example
- * ```ts
- * import { makeIdFiltersToMatchWithQuery } from '@rolldown/pluginutils';
- * const plugin = {
- *   name: 'plugin',
- *   transform: {
- *     filter: { id: makeIdFiltersToMatchWithQuery(['**' + '/*.js', /\.ts$/]) },
- *     // The handler will be called for IDs like:
- *     // - foo.js
- *     // - foo.js?foo
- *     // - foo.txt?foo.js
- *     // - foo.ts
- *     // - foo.ts?foo
- *     // - foo.txt?foo.ts
- *     handler(code, id) {}
- *   }
- * }
- * ```
- */
-declare function makeIdFiltersToMatchWithQuery<T extends string | RegExp>(input: T): WidenString<T>;
-declare function makeIdFiltersToMatchWithQuery<T extends string | RegExp>(input: readonly T[]): WidenString<T>[];
-declare function makeIdFiltersToMatchWithQuery(input: string | RegExp | readonly (string | RegExp)[]): string | RegExp | (string | RegExp)[];
-//#endregion
-export { FilterExpression, FilterExpressionKind, QueryFilterObject, TopLevelFilterExpression, and, code, exactRegex, exclude, exprInterpreter, filterVitePlugins, id, importerId, include, interpreter, interpreterImpl, makeIdFiltersToMatchWithQuery, moduleType, not, or, prefixRegex, queries, query, withFilter };