silgi 0.3.13 → 0.4.1

package/dist/shared/silgi.D2yb1XAa.mjs

@@ -1,842 +0,0 @@
-import { lstatSync, promises, existsSync } from 'node:fs';
-import { isAbsolute, dirname, resolve, join, relative, basename, normalize } from 'pathe';
-import { Buffer } from 'node:buffer';
-import { klona } from 'klona';
-import { createStorage as createStorage$1, builtinDrivers, prefixStorage } from 'unstorage';
-import memoryDriver from 'unstorage/drivers/memory';
-import { getContext } from 'unctx';
-import { loadConfig } from 'c12';
-import { defineUntypedSchema, applyDefaults } from 'untyped';
-import { isDevelopment, isTest, isDebug } from 'std-env';
-import { fileURLToPath } from 'node:url';
-import { resolvePath as resolvePath$1 } from 'mlly';
-import { resolveAlias as resolveAlias$1 } from 'pathe/utils';
-
-const silgiCtx = getContext("silgi");
-function useShared() {
-  const instance = silgiCtx.tryUse();
-  if (!instance) {
-    throw new Error("Silgi instance is unavailable!");
-  }
-  return instance.options.shared;
-}
-function useSilgi() {
-  const instance = silgiCtx.tryUse();
-  if (!instance) {
-    throw new Error("Silgi instance is unavailable!");
-  }
-  return instance;
-}
-function useHook() {
-  const instance = silgiCtx.tryUse();
-  if (!instance) {
-    throw new Error("Silgi instance is unavailable!");
-  }
-  return instance.hooks.hook;
-}
-function normalizeResult(result) {
-  if (Array.isArray(result)) {
-    return [...result];
-  }
-  if (result && typeof result === "object") {
-    if (Object.keys(result).every((key) => !Number.isNaN(Number(key)))) {
-      return Object.values(result);
-    }
-    return { ...result };
-  }
-  return result;
-}
-function tryUseSilgi() {
-  return silgiCtx.tryUse();
-}
-
-function getDirectory(p) {
-  try {
-    return isAbsolute(p) && lstatSync(p).isFile() ? dirname(p) : p;
-  } catch {
-  }
-  return p;
-}
-async function loadSilgiModuleInstance(silgiModule) {
-  if (typeof silgiModule === "string") {
-    throw new TypeError(`Could not load \`${silgiModule}\`. Is it installed?`);
-  }
-  if (typeof silgiModule !== "function") {
-    throw new TypeError(`Nuxt module should be a function: ${silgiModule}`);
-  }
-  return { silgiModule };
-}
-
-const common = defineUntypedSchema({
-  /**
-   * Environment to use.
-   *
-   * @default 'nitrojs'
-   */
-  environment: {
-    $resolve: (val) => val ?? "h3"
-  },
-  /**
-   * Define the root directory of your application.
-   *
-   * This property can be overwritten (for example, running `nuxt ./my-app/`
-   * will set the `rootDir` to the absolute path of `./my-app/` from the
-   * current/working directory.
-   *
-   * It is normally not needed to configure this option.
-   */
-  rootDir: {
-    $resolve: (val) => typeof val === "string" ? resolve(val) : process.cwd()
-  },
-  // /**
-  //  * Define the workspace directory of your application.
-  //  *
-  //  * Often this is used when in a monorepo setup. Nuxt will attempt to detect
-  //  * your workspace directory automatically, but you can override it here.
-  //  *
-  //  * It is normally not needed to configure this option.
-  //  */
-  // workspaceDir: {
-  //   $resolve: async (val: string | undefined, get): Promise<string> => {
-  //     const rootDir = await get('rootDir') as string
-  //     return val ? resolve(rootDir, val) : await findWorkspaceDir(rootDir).catch(() => rootDir)
-  //   },
-  // },
-  /**
-   * Define the server directory of your Nuxt application, where Nitro
-   * routes, middleware and plugins are kept.
-   *
-   * If a relative path is specified, it will be relative to your `rootDir`.
-   *
-   */
-  serverDir: {
-    $resolve: async (val, get) => {
-      if (val) {
-        const rootDir = await get("rootDir");
-        return resolve(rootDir, val);
-      }
-      return join(await get("rootDir"), "server");
-    }
-  },
-  silgiDir: {
-    $resolve: async (val, get) => {
-      if (val) {
-        return resolve(await get("rootDir"), val);
-      }
-      return join(await get("serverDir"), "silgi");
-    }
-  },
-  /**
-   * Define the directory where your built Nuxt files will be placed.
-   *
-   * Many tools assume that `.nuxt` is a hidden directory (because it starts
-   * with a `.`). If that is a problem, you can use this option to prevent that.
-   * @example
-   * ```js
-   * export default {
-   *   buildDir: 'nuxt-build'
-   * }
-   * ```
-   */
-  buildDir: {
-    $resolve: async (val, get) => {
-      const rootDir = await get("rootDir");
-      return resolve(rootDir, val ?? ".silgi");
-    }
-  },
-  /**
-   * Used to set the modules directories for path resolving (for example, webpack's
-   * `resolveLoading`, `nodeExternals` and `postcss`).
-   *
-   * The configuration path is relative to `options.rootDir` (default is current working directory).
-   *
-   * Setting this field may be necessary if your project is organized as a yarn workspace-styled mono-repository.
-   * @example
-   * ```js
-   * export default {
-   *   modulesDir: ['../../node_modules']
-   * }
-   * ```
-   */
-  modulesDir: {
-    $default: ["node_modules"],
-    $resolve: async (val, get) => {
-      const rootDir = await get("rootDir");
-      return [.../* @__PURE__ */ new Set([
-        ...(val || []).map((dir) => resolve(rootDir, dir)),
-        resolve(rootDir, "node_modules")
-      ])];
-    }
-  },
-  /**
-   * Whether Nuxt is running in development mode.
-   *
-   * Normally, you should not need to set this.
-   */
-  dev: {
-    $resolve: (val) => val ?? Boolean(isDevelopment)
-  },
-  /**
-   * Whether your app is being unit tested.
-   */
-  test: {
-    $resolve: (val) => val ?? Boolean(isTest)
-  },
-  /**
-   * Set to `true` to enable debug mode.
-   *
-   * At the moment, it prints out hook names and timings on the server, and
-   * logs hook arguments as well in the browser.
-   *
-   */
-  debug: {
-    $resolve: (val) => val ?? isDebug
-  },
-  /**
-   * Modules are Nuxt extensions which can extend its core functionality and add endless integrations.
-   *
-   * Each module is either a string (which can refer to a package, or be a path to a file), a
-   * tuple with the module as first string and the options as a second object, or an inline module function.
-   *
-   * Nuxt tries to resolve each item in the modules array using node require path
-   * (in `node_modules`) and then will be resolved from project `srcDir` if `~` alias is used.
-   * @note Modules are executed sequentially so the order is important. First, the modules defined in `nuxt.config.ts` are loaded. Then, modules found in the `modules/`
-   * directory are executed, and they load in alphabetical order.
-   * @example
-   * ```js
-   * modules: [
-   *   // Using package name
-   *   '@nuxtjs/axios',
-   *   // Relative to your project srcDir
-   *   '~/modules/awesome.js',
-   *   // Providing options
-   *   ['@nuxtjs/google-analytics', { ua: 'X1234567' }],
-   *   // Inline definition
-   *   function () {}
-   * ]
-   * ```
-   * @type {(typeof import('../src/types/module').NuxtModule<any> | string | [typeof import('../src/types/module').NuxtModule | string, Record<string, any>] | undefined | null | false)[]}
-   */
-  modules: {
-    $resolve: (val) => (val || []).filter(Boolean)
-  },
-  /**
-   * Hooks are listeners to Nuxt events that are typically used in modules,
-   * but are also available in `nuxt.config`.
-   *
-   * Internally, hooks follow a naming pattern using colons (e.g., build:done).
-   *
-   * For ease of configuration, you can also structure them as an hierarchical
-   * object in `nuxt.config` (as below).
-   * @example
-   * ```js
-   * import fs from 'node:fs'
-   * import path from 'node:path'
-   * export default {
-   *   hooks: {
-   *     build: {
-   *       done(builder) {
-   *         const extraFilePath = path.join(
-   *           builder.nuxt.options.buildDir,
-   *           'extra-file'
-   *         )
-   *         fs.writeFileSync(extraFilePath, 'Something extra')
-   *       }
-   *     }
-   *   }
-   * }
-   * ```
-   * @type {typeof import('../src/types/hooks').NuxtHooks}
-   */
-  hooks: null,
-  /**
-   * Customize default directory structure used by Nuxt.
-   *
-   * It is better to stick with defaults unless needed.
-   */
-  dir: {
-    client: {
-      $resolve: async (val, get) => {
-        const [srcDir, rootDir] = await Promise.all([get("srcDir"), get("rootDir")]);
-        return resolve(await get("srcDir"), val || (srcDir === rootDir ? "app" : "."));
-      }
-    },
-    /**
-     * The modules directory, each file in which will be auto-registered as a Nuxt module.
-     */
-    modules: {
-      $resolve: async (val, get) => {
-        if (val) {
-          return join(await get("rootDir"), val);
-        }
-        return resolve(await get("serverDir"), "silgi/modules");
-      }
-    },
-    /**
-     * The shared directory. This directory is shared between the app and the server.
-     */
-    shared: {
-      $resolve: async (val, get) => {
-        return resolve(await get("rootDir"), val || "shared");
-      }
-    },
-    /**
-     * The directory containing your static files, which will be directly accessible via the Nuxt server
-     * and copied across into your `dist` folder when your app is generated.
-     */
-    public: {
-      $resolve: async (val, get) => {
-        return resolve(await get("rootDir"), val || "public");
-      }
-    }
-  },
-  /**
-   * More customizable than `ignorePrefix`: all files matching glob patterns specified
-   * inside the `ignore` array will be ignored in building.
-   */
-  ignore: {
-    $resolve: async (val, get) => {
-      const [rootDir, ignorePrefix, analyzeDir, buildDir] = await Promise.all([get("rootDir"), get("ignorePrefix"), get("analyzeDir"), get("buildDir")]);
-      return [
-        "**/*.stories.{js,cts,mts,ts,jsx,tsx}",
-        // ignore storybook files
-        "**/*.{spec,test}.{js,cts,mts,ts,jsx,tsx}",
-        // ignore tests
-        "**/*.d.{cts,mts,ts}",
-        // ignore type declarations
-        "**/.{pnpm-store,vercel,netlify,output,git,cache,data}",
-        relative(rootDir, analyzeDir),
-        relative(rootDir, buildDir),
-        ignorePrefix && `**/${ignorePrefix}*.*`,
-        ...val || []
-      ].filter(Boolean);
-    }
-  },
-  /**
-   * You can improve your DX by defining additional aliases to access custom directories
-   * within your JavaScript and CSS.
-   * @note Within a webpack context (image sources, CSS - but not JavaScript) you _must_ access
-   * your alias by prefixing it with `~`.
-   * @note These aliases will be automatically added to the generated `.nuxt/tsconfig.json` so you can get full
-   * type support and path auto-complete. In case you need to extend options provided by `./.nuxt/tsconfig.json`
-   * further, make sure to add them here or within the `typescript.tsConfig` property in `nuxt.config`.
-   * @example
-   * ```js
-   * export default {
-   *   alias: {
-   *     'images': fileURLToPath(new URL('./assets/images', import.meta.url)),
-   *     'style': fileURLToPath(new URL('./assets/style', import.meta.url)),
-   *     'data': fileURLToPath(new URL('./assets/other/data', import.meta.url))
-   *   }
-   * }
-   * ```
-   *
-   * ```html
-   * <template>
-   *   <img src="~images/main-bg.jpg">
-   * </template>
-   *
-   * <script>
-   * import data from 'data/test.json'
-   * <\/script>
-   *
-   * <style>
-   * // Uncomment the below
-   * //@import '~style/variables.scss';
-   * //@import '~style/utils.scss';
-   * //@import '~style/base.scss';
-   * body {
-   *   background-image: url('~images/main-bg.jpg');
-   * }
-   * </style>
-   * ```
-   * @type {Record<string, string>}
-   */
-  alias: {
-    $resolve: async (val, get) => {
-      const [srcDir, rootDir, assetsDir, publicDir, _buildDir, sharedDir, silgiDir] = await Promise.all([get("srcDir"), get("rootDir"), get("dir.assets"), get("dir.public"), get("buildDir"), get("dir.shared"), get("silgiDir")]);
-      return {
-        "~": srcDir,
-        "@": srcDir,
-        "~~": rootDir,
-        "@@": rootDir,
-        "#shared": resolve(rootDir, sharedDir),
-        [basename(assetsDir)]: resolve(srcDir, assetsDir),
-        [basename(publicDir)]: resolve(srcDir, publicDir),
-        "#silgi": silgiDir,
-        // '#build': buildDir,
-        // '#internal/nuxt/paths': resolve(buildDir, 'paths.mjs'),
-        ...val
-      };
-    }
-  },
-  $schema: {}
-});
-
-const internal = defineUntypedSchema({
-  isPackage: false,
-  /** @private */
-  _majorVersion: 4,
-  /** @private */
-  _legacyGenerate: false,
-  /** @private */
-  _start: false,
-  /** @private */
-  _build: false,
-  /** @private */
-  _generate: false,
-  /** @private */
-  _prepare: false,
-  /** @private */
-  _cli: false,
-  /** @private */
-  _requiredModules: {},
-  /** @private */
-  _silgiConfigFile: undefined,
-  /** @private */
-  _silgiConfigFiles: [],
-  /**
-   * @private
-   * @type {Array<{ meta: ModuleMeta; timings?: Record<string, number | undefined>; entryPath?: string }>}
-   */
-  _installedModules: [],
-  /** @private */
-  _modules: [],
-  extensions: [".js", ".mjs", ".ts"]
-});
-
-const typescript = defineUntypedSchema({
-  /**
-   * Configuration for Nuxt's TypeScript integration.
-   *
-   */
-  typescript: {
-    /**
-     * TypeScript comes with certain checks to give you more safety and analysis of your program.
-     * Once you’ve converted your codebase to TypeScript, you can start enabling these checks for greater safety.
-     * [Read More](https://www.typescriptlang.org/docs/handbook/migrating-from-javascript.html#getting-stricter-checks)
-     */
-    strict: true,
-    /**
-     * Which builder types to include for your project.
-     *
-     * By default Nuxt infers this based on your `builder` option (defaulting to 'vite') but you can either turn off
-     * builder environment types (with `false`) to handle this fully yourself, or opt for a 'shared' option.
-     *
-     * The 'shared' option is advised for module authors, who will want to support multiple possible builders.
-     * @type {'vite' | 'webpack' | 'rspack' | 'shared' | false | undefined}
-     */
-    builder: {
-      $resolve: (val) => val ?? null
-    },
-    /**
-     * Modules to generate deep aliases for within `compilerOptions.paths`. This does not yet support subpaths.
-     * It may be necessary when using Nuxt within a pnpm monorepo with `shamefully-hoist=false`.
-     */
-    hoist: {
-      $resolve: (val) => {
-        const defaults = [
-          // Nitro auto-imported/augmented dependencies
-          "nitro/types",
-          "nitro/runtime",
-          "defu",
-          "h3",
-          "consola",
-          "ofetch",
-          // Key nuxt dependencies
-          "@unhead/vue",
-          "@nuxt/devtools",
-          "vue",
-          "@vue/runtime-core",
-          "@vue/compiler-sfc",
-          "vue-router",
-          "vue-router/auto-routes",
-          "unplugin-vue-router/client",
-          "@nuxt/schema",
-          "nuxt"
-        ];
-        return val === false ? [] : Array.isArray(val) ? val.concat(defaults) : defaults;
-      }
-    },
-    /**
-     * Include parent workspace in the Nuxt project. Mostly useful for themes and module authors.
-     */
-    includeWorkspace: false,
-    /**
-     * Enable build-time type checking.
-     *
-     * If set to true, this will type check in development. You can restrict this to build-time type checking by setting it to `build`.
-     * Requires to install `typescript` and `vue-tsc` as dev dependencies.
-     * @see [Nuxt TypeScript docs](https://nuxt.com/docs/guide/concepts/typescript)
-     * @type {boolean | 'build'}
-     */
-    typeCheck: false,
-    /**
-     * You can extend generated `.nuxt/tsconfig.json` using this option.
-     * @type {0 extends 1 & VueCompilerOptions ? typeof import('pkg-types')['TSConfig'] : typeof import('pkg-types')['TSConfig'] & { vueCompilerOptions?: Omit<typeof import('@vue/language-core')['VueCompilerOptions'], 'plugins'> & { plugins?: string[] } }}
-     */
-    tsConfig: {},
-    /**
-     * Generate a `*.vue` shim.
-     *
-     * We recommend instead letting the [official Vue extension](https://marketplace.visualstudio.com/items?itemName=Vue.volar)
-     * generate accurate types for your components.
-     *
-     * Note that you may wish to set this to `true` if you are using other libraries, such as ESLint,
-     * that are unable to understand the type of `.vue` files.
-     */
-    shim: false
-  }
-});
-
-const SilgiConfigSchema = {
-  ...common,
-  ...internal,
-  ...typescript
-};
-
-var SilgiErrorCode = /* @__PURE__ */ ((SilgiErrorCode2) => {
-  SilgiErrorCode2["AUTH_UNAUTHORIZED"] = "AUTH_UNAUTHORIZED";
-  SilgiErrorCode2["AUTH_MISSING_CONTEXT"] = "AUTH_MISSING_CONTEXT";
-  SilgiErrorCode2["AUTH_INVALID_CONTEXT"] = "AUTH_INVALID_CONTEXT";
-  SilgiErrorCode2["AUTH_PERMISSION_DENIED"] = "AUTH_PERMISSION_DENIED";
-  SilgiErrorCode2["PLUGIN_ERROR"] = "PLUGIN_ERROR";
-  SilgiErrorCode2["METHOD_NOT_FOUND"] = "METHOD_NOT_FOUND";
-  SilgiErrorCode2["EXECUTION_ERROR"] = "EXECUTION_ERROR";
-  SilgiErrorCode2["CACHE_ERROR"] = "CACHE_ERROR";
-  SilgiErrorCode2["PLUGIN_ALREADY_EXISTS"] = "PLUGIN_ALREADY_EXISTS";
-  SilgiErrorCode2["PLUGIN_NOT_FOUND"] = "PLUGIN_NOT_FOUND";
-  SilgiErrorCode2["PLUGIN_INIT_ERROR"] = "PLUGIN_INIT_ERROR";
-  return SilgiErrorCode2;
-})(SilgiErrorCode || {});
-class SilgiError extends Error {
-  code;
-  details;
-  meta;
-  timestamp;
-  cause;
-  constructor(options) {
-    super(options.message);
-    this.name = "SilgiError";
-    this.code = options.code;
-    this.details = options.details;
-    this.meta = options.meta;
-    this.cause = options.cause;
-    this.timestamp = Date.now();
-    if (Error.captureStackTrace) {
-      Error.captureStackTrace(this, this.constructor);
-    }
-  }
-  // Improve error formatting
-  toString() {
-    let str = `${this.name} [${this.code}]: ${this.message}`;
-    if (this.details) {
-      str += `
-Details: ${JSON.stringify(this.details, null, 2)}`;
-    }
-    if (this.meta) {
-      str += `
-Meta: ${JSON.stringify(this.meta, null, 2)}`;
-    }
-    if (this.stack) {
-      str += `
-${this.stack}`;
-    }
-    return str;
-  }
-  toJSON() {
-    return {
-      name: this.name,
-      code: this.code,
-      message: this.message,
-      details: this.details,
-      meta: this.meta,
-      timestamp: this.timestamp,
-      stack: this.stack
-    };
-  }
-  static createFrom(error, code = "UNKNOWN_ERROR") {
-    if (error instanceof SilgiError) {
-      return error;
-    }
-    return new SilgiError({
-      code,
-      message: error instanceof Error ? error.message : String(error),
-      cause: error instanceof Error ? error : undefined
-    });
-  }
-  static isSilgiError(error) {
-    return error instanceof SilgiError;
-  }
-}
-
-function traverseObject(silgi, obj, currentPath = []) {
-  const uriMap = /* @__PURE__ */ new Map();
-  function traverse(node, path = []) {
-    if (!node || typeof node !== "object")
-      return;
-    if (path.length === 4) {
-      const basePath = path.join("/");
-      let paramString = "";
-      if (node.router) {
-        let params = null;
-        if (node.router?._def?.typeName !== undefined) {
-          try {
-            const shape = node.router?.shape?.params?.shape;
-            params = shape ? Object.keys(shape) : null;
-          } catch {
-            params = null;
-          }
-        }
-        if (params?.length) {
-          paramString = params.map((p) => `:${p}`).join("/");
-        }
-      }
-      uriMap.set(basePath, paramString);
-      return;
-    }
-    for (const key in node) {
-      if (!["_type", "fields"].includes(key)) {
-        traverse(node[key], [...path, key]);
-      }
-    }
-  }
-  traverse(obj, currentPath);
-  return uriMap;
-}
-function parseURI(uri, uris) {
-  if (!uris) {
-    const silgiCtx = useSilgi();
-    uris = silgiCtx.uris;
-  }
-  uri = uri.replace("/srn", "");
-  const [cleanPath, queryString] = uri.split("?");
-  const query = new URLSearchParams(queryString);
-  const methodQuery = query.get("method")?.toLowerCase();
-  const parts = cleanPath.split("/").filter(Boolean);
-  const [namespace, service, methodOrAction, action, ...routerParams] = parts;
-  let uriKey = `${namespace}/${service}/${methodOrAction}/${action}`;
-  if (methodQuery) {
-    uriKey = `${namespace}/${service}/${methodQuery}/${methodOrAction}`;
-    routerParams.unshift(action);
-  }
-  const paramTemplate = uris[uriKey];
-  const routerParamsData = {};
-  if (paramTemplate && routerParams.length > 0) {
-    const paramNames = paramTemplate.split("/").map((p) => p.replace(":", ""));
-    routerParams.forEach((value, index) => {
-      if (paramNames[index]) {
-        routerParamsData[paramNames[index]] = value;
-      }
-    });
-  }
-  return {
-    namespaceName: namespace,
-    serviceName: service,
-    methodName: methodQuery || methodOrAction,
-    actionName: methodQuery ? methodOrAction : action,
-    raw: uri,
-    parts: [namespace, service, methodQuery || methodOrAction, action],
-    routerParams: routerParamsData,
-    query: query.toString() ? Object.fromEntries(query) : undefined,
-    uri: uriKey
-  };
-}
-
-async function createStorage(silgi) {
-  const storage = createStorage$1();
-  const mounts = klona({
-    ...silgi.options.storage,
-    ...silgi.options.devStorage
-  });
-  for (const [path, opts] of Object.entries(mounts)) {
-    if (opts.driver) {
-      const driver = await import(builtinDrivers[opts.driver] || opts.driver).then((r) => r.default || r);
-      storage.mount("/memory:cache", memoryDriver());
-      storage.mount(path, driver(opts));
-    } else {
-      silgi.logger.warn(`No \`driver\` set for storage mount point "${path}".`);
-    }
-  }
-  return storage;
-}
-function useStorage(base = "/memory:cache") {
-  const silgi = useSilgi();
-  return base ? prefixStorage(silgi.storage, base) : silgi.storage;
-}
-async function generateStorageKey(params) {
-  const {
-    operation,
-    input,
-    keyGenerator,
-    requestId,
-    storageOptions
-  } = params;
-  const cacheScopePrefix = storageOptions?.scope === "request" ? "req" : "global";
-  const parts = [
-    cacheScopePrefix,
-    // Always include scope prefix first
-    operation.namespaceName,
-    operation.serviceName,
-    operation.methodName
-  ].filter(Boolean);
-  if (storageOptions?.scope === "request") {
-    if (!requestId) {
-      throw new SilgiError({
-        code: "CACHE_ERROR",
-        message: "Request ID is required for request-scoped cache"
-      });
-    }
-    parts.push(requestId);
-  }
-  if (keyGenerator) {
-    const customKey = await Promise.resolve(keyGenerator(input));
-    parts.push(customKey);
-  } else {
-    parts.push(typeof input === "object" ? JSON.stringify(input) : String(input));
-  }
-  return Buffer.from(parts.join(":")).toString("base64");
-}
-async function generateSilgiStorageBaseType(silgi) {
-  silgi.hook("prepare:schema.ts", async (options) => {
-    if (silgi.options.storage) {
-      for (const [key, _value] of Object.entries(silgi.options.storage)) {
-        options.storeBase.push(key);
-      }
-    }
-  });
-}
-
-async function generateUris(silgi) {
-  silgi.hook("read:core.ts", async (data) => {
-    const { context, object, path } = await data();
-    const uriMap = traverseObject(silgi, object.schemas, []);
-    if (uriMap.size > 0) {
-      const uriContent = Array.from(uriMap.entries()).map(([uri, params]) => `  '${uri}': '${params}',`).join("\n");
-      const newContext = context.replace(
-        /export const uris = \{[^}]*\}/,
-        `export const uris = {
-${uriContent}
-}`
-      );
-      await promises.writeFile(path, newContext);
-    }
-  });
-}
-async function findAction(silgi, uri) {
-  const { parts } = parseURI(uri, silgi);
-  let result = silgi.services;
-  for (const part of parts) {
-    if (result && Object.prototype.hasOwnProperty.call(result, part)) {
-      result = Object.assign({}, result[part]);
-    } else {
-      console.error("Property not found:", part);
-      break;
-    }
-  }
-  return result;
-}
-async function scanAction(silgi) {
-  for (const [key, _value] of Object.entries(silgi.uris)) {
-    const handler = await findAction(silgi, key);
-    silgi.scannedHandlers.set(key, handler);
-  }
-}
-
-async function loadSilgiConfig(opts) {
-  globalThis.defineSilgiConfig = (c) => c;
-  const result = await loadConfig({
-    name: "silgi",
-    configFile: "silgi.config",
-    rcFile: ".silgirc",
-    // extend: { extendKey: ['theme', 'extends', '_extends'] },
-    dotenv: true,
-    globalRc: true,
-    ...opts
-  });
-  delete globalThis.defineSilgiConfig;
-  const { configFile, cwd } = result;
-  const silgiConfig = result.config;
-  silgiConfig.rootDir = silgiConfig.rootDir || cwd;
-  silgiConfig._silgiConfigFile = configFile;
-  silgiConfig._silgiConfigFiles = [configFile];
-  return await applyDefaults(SilgiConfigSchema, silgiConfig);
-}
-
-async function resolvePath(path, opts = {}) {
-  const _path = path;
-  path = normalize(path);
-  if (isAbsolute(path)) {
-    if (existsSync(path) && !await isDirectory(path)) {
-      return path;
-    }
-  }
-  const cwd = opts.cwd || process.cwd();
-  const extensions = opts.extensions || [".ts", ".mjs", ".cjs", ".json"];
-  const modulesDir = opts.modulesDir || [];
-  path = resolveAlias(path);
-  if (!isAbsolute(path)) {
-    path = resolve(cwd, path);
-  }
-  let _isDir = false;
-  if (existsSync(path)) {
-    _isDir = await isDirectory(path);
-    if (!_isDir) {
-      return path;
-    }
-  }
-  for (const ext of extensions) {
-    const pathWithExt = path + ext;
-    if (existsSync(pathWithExt)) {
-      return pathWithExt;
-    }
-    const pathWithIndex = join(path, `index${ext}`);
-    if (_isDir && existsSync(pathWithIndex)) {
-      return pathWithIndex;
-    }
-  }
-  const resolveModulePath = await resolvePath$1(_path, { url: [cwd, ...modulesDir] }).catch(() => null);
-  if (resolveModulePath) {
-    return resolveModulePath;
-  }
-  return opts.fallbackToOriginal ? _path : path;
-}
-async function isDirectory(path) {
-  return (await promises.lstat(path)).isDirectory();
-}
-function resolveAlias(path, alias) {
-  return resolveAlias$1(path, {});
-}
-function createResolver(base) {
-  if (!base) {
-    throw new Error("`base` argument is missing for createResolver(base)!");
-  }
-  base = base.toString();
-  if (base.startsWith("file://")) {
-    base = dirname(fileURLToPath(base));
-  }
-  return {
-    resolve: (...path) => resolve(base, ...path),
-    resolvePath: (path, opts) => resolvePath(path, { cwd: base, ...opts })
-  };
-}
-async function resolveSilgiModule(base, paths) {
-  const resolved = [];
-  const resolver = createResolver(base);
-  for (const path of paths) {
-    if (path.startsWith(base)) {
-      resolved.push(path.split("/index.ts")[0]);
-    } else {
-      const resolvedPath = await resolver.resolvePath(path);
-      resolved.push(resolvedPath.slice(0, resolvedPath.lastIndexOf(path) + path.length));
-    }
-  }
-  return resolved;
-}
-
-const RELATIVE_RE = /^([^.])/;
-function relativeWithDot(from, to) {
-  return relative(from, to).replace(RELATIVE_RE, "./$1") || ".";
-}
-
-export { SilgiError as S, loadSilgiModuleInstance as a, useStorage as b, SilgiErrorCode as c, SilgiConfigSchema as d, createStorage as e, silgiCtx as f, generateStorageKey as g, createResolver as h, useHook as i, useShared as j, getDirectory as k, loadSilgiConfig as l, resolveSilgiModule as m, normalizeResult as n, resolvePath as o, parseURI as p, generateUris as q, relativeWithDot as r, scanAction as s, tryUseSilgi as t, useSilgi as u, generateSilgiStorageBaseType as v };