@venos-inc/venos 0.1.5 → 0.1.7

package/etc/mcp-server/node_modules/@vitest/expect/index.d.ts

@@ -1,3 +0,0 @@
-import './dist/chai.cjs'
-
-export * from './dist/index.js'

package/etc/mcp-server/node_modules/@vitest/mocker/dist/mocker-pQgp1HFr.d.ts

@@ -1,78 +0,0 @@
-import { MaybeMockedDeep } from '@vitest/spy';
-import { l as ModuleMockOptions, k as ModuleMockFactoryWithHelper, g as MockedModule, c as MockerRegistry, M as MockedModuleType } from './types-DZOqTgiN.js';
-
-interface CompilerHintsOptions {
-    /**
-     * This is the key used to access the globalThis object in the worker.
-     * Unlike `globalThisAccessor` in other APIs, this is not injected into the script.
-     * ```ts
-     * // globalThisKey: '__my_variable__' produces:
-     * globalThis['__my_variable__']
-     * // globalThisKey: '"__my_variable__"' produces:
-     * globalThis['"__my_variable__"'] // notice double quotes
-     * ```
-     * @default '__vitest_mocker__'
-     */
-    globalThisKey?: string;
-}
-interface ModuleMockerCompilerHints {
-    hoisted: <T>(factory: () => T) => T;
-    mock: (path: string | Promise<unknown>, factory?: ModuleMockOptions | ModuleMockFactoryWithHelper) => void;
-    unmock: (path: string | Promise<unknown>) => void;
-    doMock: (path: string | Promise<unknown>, factory?: ModuleMockOptions | ModuleMockFactoryWithHelper) => void;
-    doUnmock: (path: string | Promise<unknown>) => void;
-    importActual: <T>(path: string) => Promise<T>;
-    importMock: <T>(path: string) => Promise<MaybeMockedDeep<T>>;
-}
-declare function createCompilerHints(options?: CompilerHintsOptions): ModuleMockerCompilerHints;
-
-interface ModuleMockerInterceptor {
-    register: (module: MockedModule) => Promise<void>;
-    delete: (url: string) => Promise<void>;
-    invalidate: () => void;
-}
-
-declare class ModuleMocker {
-    private interceptor;
-    private rpc;
-    private spyOn;
-    private config;
-    protected registry: MockerRegistry;
-    private queue;
-    private mockedIds;
-    constructor(interceptor: ModuleMockerInterceptor, rpc: ModuleMockerRPC, spyOn: (obj: any, method: string | symbol) => any, config: ModuleMockerConfig);
-    prepare(): Promise<void>;
-    resolveFactoryModule(id: string): Promise<Record<string | symbol, any>>;
-    getFactoryModule(id: string): any;
-    invalidate(): Promise<void>;
-    importActual<T>(id: string, importer: string): Promise<T>;
-    importMock<T>(rawId: string, importer: string): Promise<T>;
-    mockObject(object: Record<string | symbol, any>, moduleType?: MockedModuleType): Record<string | symbol, any>;
-    queueMock(rawId: string, importer: string, factoryOrOptions?: ModuleMockOptions | (() => any)): void;
-    queueUnmock(id: string, importer: string): void;
-    wrapDynamicImport<T>(moduleFactory: () => Promise<T>): Promise<T>;
-    private resolveMockPath;
-}
-interface ResolveIdResult {
-    id: string;
-    url: string;
-    optimized: boolean;
-}
-interface ResolveMockResul {
-    mockType: MockedModuleType;
-    resolvedId: string;
-    redirectUrl?: string | null;
-    needsInterop?: boolean;
-}
-interface ModuleMockerRPC {
-    invalidate: (ids: string[]) => Promise<void>;
-    resolveId: (id: string, importer: string) => Promise<ResolveIdResult | null>;
-    resolveMock: (id: string, importer: string, options: {
-        mock: 'spy' | 'factory' | 'auto';
-    }) => Promise<ResolveMockResul>;
-}
-interface ModuleMockerConfig {
-    root: string;
-}
-
-export { type CompilerHintsOptions as C, type ModuleMockerInterceptor as M, type ResolveIdResult as R, type ModuleMockerCompilerHints as a, ModuleMocker as b, createCompilerHints as c, type ModuleMockerConfig as d, type ModuleMockerRPC as e, type ResolveMockResul as f };

package/etc/mcp-server/node_modules/@vitest/mocker/dist/types-DZOqTgiN.d.ts

@@ -1,83 +0,0 @@
-declare class MockerRegistry {
-    private readonly registry;
-    clear(): void;
-    keys(): IterableIterator<string>;
-    add(mock: MockedModule): void;
-    register(json: MockedModuleSerialized): MockedModule;
-    register(type: 'redirect', raw: string, url: string, redirect: string): RedirectedModule;
-    register(type: 'manual', raw: string, url: string, factory: () => any): ManualMockedModule;
-    register(type: 'automock', raw: string, url: string): AutomockedModule;
-    register(type: 'autospy', raw: string, url: string): AutospiedModule;
-    delete(id: string): void;
-    get(id: string): MockedModule | undefined;
-    has(id: string): boolean;
-}
-type MockedModule = AutomockedModule | AutospiedModule | ManualMockedModule | RedirectedModule;
-type MockedModuleType = 'automock' | 'autospy' | 'manual' | 'redirect';
-type MockedModuleSerialized = AutomockedModuleSerialized | AutospiedModuleSerialized | ManualMockedModuleSerialized | RedirectedModuleSerialized;
-declare class AutomockedModule {
-    raw: string;
-    url: string;
-    readonly type = "automock";
-    constructor(raw: string, url: string);
-    static fromJSON(data: AutomockedModuleSerialized): AutospiedModule;
-    toJSON(): AutomockedModuleSerialized;
-}
-interface AutomockedModuleSerialized {
-    type: 'automock';
-    url: string;
-    raw: string;
-}
-declare class AutospiedModule {
-    raw: string;
-    url: string;
-    readonly type = "autospy";
-    constructor(raw: string, url: string);
-    static fromJSON(data: AutospiedModuleSerialized): AutospiedModule;
-    toJSON(): AutospiedModuleSerialized;
-}
-interface AutospiedModuleSerialized {
-    type: 'autospy';
-    url: string;
-    raw: string;
-}
-declare class RedirectedModule {
-    raw: string;
-    url: string;
-    redirect: string;
-    readonly type = "redirect";
-    constructor(raw: string, url: string, redirect: string);
-    static fromJSON(data: RedirectedModuleSerialized): RedirectedModule;
-    toJSON(): RedirectedModuleSerialized;
-}
-interface RedirectedModuleSerialized {
-    type: 'redirect';
-    url: string;
-    raw: string;
-    redirect: string;
-}
-declare class ManualMockedModule {
-    raw: string;
-    url: string;
-    factory: () => any;
-    cache: Record<string | symbol, any> | undefined;
-    readonly type = "manual";
-    constructor(raw: string, url: string, factory: () => any);
-    resolve(): Promise<Record<string | symbol, any>>;
-    static fromJSON(data: ManualMockedModuleSerialized, factory: () => any): ManualMockedModule;
-    toJSON(): ManualMockedModuleSerialized;
-}
-interface ManualMockedModuleSerialized {
-    type: 'manual';
-    url: string;
-    raw: string;
-}
-
-type Awaitable<T> = T | PromiseLike<T>;
-type ModuleMockFactoryWithHelper<M = unknown> = (importOriginal: <T extends M = M>() => Promise<T>) => Awaitable<Partial<M>>;
-type ModuleMockFactory = () => any;
-interface ModuleMockOptions {
-    spy?: boolean;
-}
-
-export { AutomockedModule as A, type MockedModuleType as M, RedirectedModule as R, AutospiedModule as a, ManualMockedModule as b, MockerRegistry as c, type AutomockedModuleSerialized as d, type AutospiedModuleSerialized as e, type ManualMockedModuleSerialized as f, type MockedModule as g, type MockedModuleSerialized as h, type RedirectedModuleSerialized as i, type ModuleMockFactory as j, type ModuleMockFactoryWithHelper as k, type ModuleMockOptions as l };

package/etc/mcp-server/node_modules/@vitest/runner/dist/chunk-tasks.js

@@ -1,249 +0,0 @@
-import { processError } from '@vitest/utils/error';
-import { relative } from 'pathe';
-import { toArray } from '@vitest/utils';
-
-function createChainable(keys, fn) {
-  function create(context) {
-    const chain2 = function(...args) {
-      return fn.apply(context, args);
-    };
-    Object.assign(chain2, fn);
-    chain2.withContext = () => chain2.bind(context);
-    chain2.setContext = (key, value) => {
-      context[key] = value;
-    };
-    chain2.mergeContext = (ctx) => {
-      Object.assign(context, ctx);
-    };
-    for (const key of keys) {
-      Object.defineProperty(chain2, key, {
-        get() {
-          return create({ ...context, [key]: true });
-        }
-      });
-    }
-    return chain2;
-  }
-  const chain = create({});
-  chain.fn = fn;
-  return chain;
-}
-
-function interpretTaskModes(suite, namePattern, onlyMode, parentIsOnly, allowOnly) {
-  const suiteIsOnly = parentIsOnly || suite.mode === "only";
-  suite.tasks.forEach((t) => {
-    const includeTask = suiteIsOnly || t.mode === "only";
-    if (onlyMode) {
-      if (t.type === "suite" && (includeTask || someTasksAreOnly(t))) {
-        if (t.mode === "only") {
-          checkAllowOnly(t, allowOnly);
-          t.mode = "run";
-        }
-      } else if (t.mode === "run" && !includeTask) {
-        t.mode = "skip";
-      } else if (t.mode === "only") {
-        checkAllowOnly(t, allowOnly);
-        t.mode = "run";
-      }
-    }
-    if (t.type === "test") {
-      if (namePattern && !getTaskFullName(t).match(namePattern)) {
-        t.mode = "skip";
-      }
-    } else if (t.type === "suite") {
-      if (t.mode === "skip") {
-        skipAllTasks(t);
-      } else {
-        interpretTaskModes(t, namePattern, onlyMode, includeTask, allowOnly);
-      }
-    }
-  });
-  if (suite.mode === "run") {
-    if (suite.tasks.length && suite.tasks.every((i) => i.mode !== "run")) {
-      suite.mode = "skip";
-    }
-  }
-}
-function getTaskFullName(task) {
-  return `${task.suite ? `${getTaskFullName(task.suite)} ` : ""}${task.name}`;
-}
-function someTasksAreOnly(suite) {
-  return suite.tasks.some(
-    (t) => t.mode === "only" || t.type === "suite" && someTasksAreOnly(t)
-  );
-}
-function skipAllTasks(suite) {
-  suite.tasks.forEach((t) => {
-    if (t.mode === "run") {
-      t.mode = "skip";
-      if (t.type === "suite") {
-        skipAllTasks(t);
-      }
-    }
-  });
-}
-function checkAllowOnly(task, allowOnly) {
-  if (allowOnly) {
-    return;
-  }
-  const error = processError(
-    new Error(
-      "[Vitest] Unexpected .only modifier. Remove it or pass --allowOnly argument to bypass this error"
-    )
-  );
-  task.result = {
-    state: "fail",
-    errors: [error]
-  };
-}
-function generateHash(str) {
-  let hash = 0;
-  if (str.length === 0) {
-    return `${hash}`;
-  }
-  for (let i = 0; i < str.length; i++) {
-    const char = str.charCodeAt(i);
-    hash = (hash << 5) - hash + char;
-    hash = hash & hash;
-  }
-  return `${hash}`;
-}
-function calculateSuiteHash(parent) {
-  parent.tasks.forEach((t, idx) => {
-    t.id = `${parent.id}_${idx}`;
-    if (t.type === "suite") {
-      calculateSuiteHash(t);
-    }
-  });
-}
-function createFileTask(filepath, root, projectName, pool) {
-  const path = relative(root, filepath);
-  const file = {
-    id: generateHash(`${path}${projectName || ""}`),
-    name: path,
-    type: "suite",
-    mode: "run",
-    filepath,
-    tasks: [],
-    meta: /* @__PURE__ */ Object.create(null),
-    projectName,
-    file: void 0,
-    pool
-  };
-  file.file = file;
-  return file;
-}
-
-function limitConcurrency(concurrency = Infinity) {
-  let count = 0;
-  let head;
-  let tail;
-  const finish = () => {
-    count--;
-    if (head) {
-      head[0]();
-      head = head[1];
-      tail = head && tail;
-    }
-  };
-  return (func, ...args) => {
-    return new Promise((resolve) => {
-      if (count++ < concurrency) {
-        resolve();
-      } else if (tail) {
-        tail = tail[1] = [resolve];
-      } else {
-        head = tail = [resolve];
-      }
-    }).then(() => {
-      return func(...args);
-    }).finally(finish);
-  };
-}
-
-function partitionSuiteChildren(suite) {
-  let tasksGroup = [];
-  const tasksGroups = [];
-  for (const c of suite.tasks) {
-    if (tasksGroup.length === 0 || c.concurrent === tasksGroup[0].concurrent) {
-      tasksGroup.push(c);
-    } else {
-      tasksGroups.push(tasksGroup);
-      tasksGroup = [c];
-    }
-  }
-  if (tasksGroup.length > 0) {
-    tasksGroups.push(tasksGroup);
-  }
-  return tasksGroups;
-}
-
-function isAtomTest(s) {
-  return s.type === "test" || s.type === "custom";
-}
-function getTests(suite) {
-  const tests = [];
-  const arraySuites = toArray(suite);
-  for (const s of arraySuites) {
-    if (isAtomTest(s)) {
-      tests.push(s);
-    } else {
-      for (const task of s.tasks) {
-        if (isAtomTest(task)) {
-          tests.push(task);
-        } else {
-          const taskTests = getTests(task);
-          for (const test of taskTests) {
-            tests.push(test);
-          }
-        }
-      }
-    }
-  }
-  return tests;
-}
-function getTasks(tasks = []) {
-  return toArray(tasks).flatMap(
-    (s) => isAtomTest(s) ? [s] : [s, ...getTasks(s.tasks)]
-  );
-}
-function getSuites(suite) {
-  return toArray(suite).flatMap(
-    (s) => s.type === "suite" ? [s, ...getSuites(s.tasks)] : []
-  );
-}
-function hasTests(suite) {
-  return toArray(suite).some(
-    (s) => s.tasks.some((c) => isAtomTest(c) || hasTests(c))
-  );
-}
-function hasFailed(suite) {
-  return toArray(suite).some(
-    (s) => {
-      var _a;
-      return ((_a = s.result) == null ? void 0 : _a.state) === "fail" || s.type === "suite" && hasFailed(s.tasks);
-    }
-  );
-}
-function getNames(task) {
-  const names = [task.name];
-  let current = task;
-  while (current == null ? void 0 : current.suite) {
-    current = current.suite;
-    if (current == null ? void 0 : current.name) {
-      names.unshift(current.name);
-    }
-  }
-  if (current !== task.file) {
-    names.unshift(task.file.name);
-  }
-  return names;
-}
-function getFullName(task, separator = " > ") {
-  return getNames(task).join(separator);
-}
-function getTestName(task, separator = " > ") {
-  return getNames(task).slice(1).join(separator);
-}
-
-export { calculateSuiteHash as a, createFileTask as b, createChainable as c, getFullName as d, getNames as e, getSuites as f, generateHash as g, getTasks as h, interpretTaskModes as i, getTestName as j, getTests as k, limitConcurrency as l, hasFailed as m, hasTests as n, isAtomTest as o, partitionSuiteChildren as p, someTasksAreOnly as s };