silgi 0.7.1 → 0.7.2

package/dist/cli/utils/uri.mjs

@@ -1,71 +0,0 @@
-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 !== void 0) {
-          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 scanActionModulesUris(silgi, obj, currentPath = []) {
-  const uriMap = {};
-  function traverse(node, path = []) {
-    if (!node || typeof node !== "object")
-      return;
-    if (path.length === 4) {
-      const basePath = path.join("/");
-      let moduleName = "";
-      if (node.modules?.yoga) {
-        let rootFieldName = null;
-        if (node.modules?.yoga?.rootFieldName) {
-          moduleName = "yoga";
-          rootFieldName = node.modules?.yoga?.rootFieldName;
-        }
-        if (!rootFieldName) {
-          return;
-        }
-        uriMap[moduleName] ??= {};
-        if (uriMap[moduleName].rootFieldName) {
-          silgi.logger.withTag("scanActionModulesUris").error(`Hata ${moduleName} ${rootFieldName} ${basePath} bu zaten burada kullanilmis.`);
-        }
-        uriMap[moduleName].rootFieldName ??= {};
-        uriMap[moduleName].rootFieldName[rootFieldName] = basePath;
-      }
-      return;
-    }
-    for (const key in node) {
-      if (!["_type", "fields"].includes(key)) {
-        traverse(node[key], [...path, key]);
-      }
-    }
-  }
-  traverse(obj, currentPath);
-  return uriMap;
-}
-
-export { scanActionModulesUris, traverseObject };

package/dist/core/config/defaults.mjs

@@ -1,96 +0,0 @@
-import { isDebug, isTest } from 'std-env';
-
-const SilgiCLIDefaults = {
-  // General
-  debug: isDebug,
-  // timing: isDebug,
-  logLevel: isTest ? 1 : 3,
-  // runtimeConfig: { app: {}, silgi: {} },
-  appConfig: {},
-  appConfigFiles: [],
-  // Dirs
-  scanDirs: [],
-  build: {
-    dir: ".silgi",
-    typesDir: "{{ build.dir }}/types",
-    templates: []
-  },
-  output: {
-    dir: "{{ rootDir }}/.output",
-    serverDir: "{{ output.dir }}/server",
-    publicDir: "{{ output.dir }}/public"
-  },
-  serverDir: "{{ rootDir }}/server",
-  clientDir: "{{ rootDir }}/client",
-  silgi: {
-    serverDir: "{{ serverDir }}/silgi",
-    clientDir: "{{ clientDir }}/silgi",
-    publicDir: "{{ silgi.serverDir }}/public",
-    utilsDir: "{{ silgi.serverDir }}/utils",
-    vfsDir: "{{ silgi.serverDir }}/vfs",
-    typesDir: "{{ silgi.serverDir }}/types"
-  },
-  // Modules
-  _modules: [],
-  modules: [],
-  // Features
-  // experimental: {},
-  future: {},
-  storage: {},
-  devStorage: {},
-  stub: false,
-  // bundledStorage: [],
-  // publicAssets: [],
-  // serverAssets: [],
-  plugins: [],
-  // tasks: {},
-  // scheduledTasks: {},
-  imports: {
-    exclude: [],
-    dirs: [],
-    presets: [],
-    virtualImports: ["#silgiImports"]
-  },
-  // virtual: {},
-  // compressPublicAssets: false,
-  ignore: [],
-  // Dev
-  dev: false,
-  // devServer: { watch: [] },
-  watchOptions: { ignoreInitial: true },
-  // devProxy: {},
-  // Logging
-  // logging: {
-  //   compressedSizes: true,
-  //   buildSuccess: true,
-  // },
-  // Routing
-  // baseURL: process.env.NITRO_APP_BASE_URL || '/',
-  // handlers: [],
-  // devHandlers: [],
-  // errorHandler: undefined,
-  // routeRules: {},
-  // Advanced
-  typescript: {
-    strict: false,
-    generateTsConfig: true,
-    // generateRuntimeConfigTypes: true,
-    tsconfigPath: "types/silgi.tsconfig.json",
-    internalPaths: false,
-    tsConfig: {},
-    customConditions: []
-  },
-  conditions: [],
-  nodeModulesDirs: [],
-  // hooks: {},
-  commands: {},
-  // Framework
-  framework: {
-    name: "h3",
-    version: ""
-  },
-  extensions: [".js", ".jsx", ".mjs", ".ts", ".tsx", ".vue"],
-  ignoreOptions: void 0
-};
-
-export { SilgiCLIDefaults };

package/dist/core/config/loader.mjs

@@ -1,98 +0,0 @@
-import { watchConfig, loadConfig } from 'c12';
-import { resolveCompatibilityDates } from 'compatx';
-import { klona } from 'klona/full';
-import { SilgiCLIDefaults } from './defaults.mjs';
-import { resolveCompatibilityOptions, fallbackCompatibilityDate } from './resolvers/compatibility.mjs';
-import { resolveImportsOptions } from './resolvers/imports.mjs';
-import { resolvePathOptions } from './resolvers/paths.mjs';
-import { resolveStorageOptions } from './resolvers/storage.mjs';
-import { resolveURLOptions } from './resolvers/url.mjs';
-
-const configResolvers = [
-  resolveCompatibilityOptions,
-  resolvePathOptions,
-  resolveImportsOptions,
-  // resolveRouteRulesOptions,
-  // resolveDatabaseOptions,
-  // resolveFetchOptions,
-  // resolveExportConditionsOptions,
-  // resolveRuntimeConfigOptions,
-  // resolveOpenAPIOptions,
-  resolveURLOptions,
-  // resolveAssetsOptions,
-  resolveStorageOptions
-  // resolveErrorOptions,
-];
-async function loadOptions(configOverrides = {}, opts = {}) {
-  const options = await _loadUserConfig(configOverrides, opts);
-  for (const resolver of configResolvers) {
-    await resolver(options);
-  }
-  return options;
-}
-async function _loadUserConfig(configOverrides = {}, opts = {}) {
-  const presetOverride = configOverrides.preset || process.env.SILGI_PRESET;
-  if (configOverrides.dev) ;
-  configOverrides = klona(configOverrides);
-  globalThis.defineSilgiConfig = globalThis.defineSilgiConfig || ((c) => c);
-  let compatibilityDate = configOverrides.compatibilityDate || opts.compatibilityDate || (process.env.SILGI_COMPATIBILITY_DATE || process.env.SERVER_COMPATIBILITY_DATE || process.env.COMPATIBILITY_DATE);
-  const { resolvePreset } = await import('silgi/presets');
-  const loadedConfig = await (opts.watch ? watchConfig : loadConfig)({
-    name: "silgi",
-    cwd: configOverrides.rootDir,
-    dotenv: configOverrides.dev,
-    extend: { extendKey: ["extends", "preset"] },
-    overrides: {
-      ...configOverrides,
-      preset: presetOverride
-    },
-    async defaultConfig({ configs }) {
-      const getConf = (key) => configs.main?.[key] ?? configs.rc?.[key] ?? configs.packageJson?.[key];
-      if (!compatibilityDate) {
-        compatibilityDate = getConf("compatibilityDate");
-      }
-      return {
-        // typescript: {
-        //   generateRuntimeConfigTypes:
-        //     !framework?.name || framework.name === 'nitro',
-        // },
-        preset: presetOverride || (await resolvePreset("", {
-          static: getConf("static"),
-          compatibilityDate: compatibilityDate || fallbackCompatibilityDate
-        }))?._meta?.name
-      };
-    },
-    defaults: SilgiCLIDefaults,
-    jitiOptions: {
-      alias: {
-        "silgi": "silgi/config",
-        "silgi/config": "silgi/config"
-      }
-    },
-    async resolve(id) {
-      const preset = await resolvePreset(id, {
-        static: configOverrides.static,
-        compatibilityDate: compatibilityDate || fallbackCompatibilityDate
-      });
-      if (preset) {
-        return {
-          config: klona(preset)
-        };
-      }
-    },
-    ...opts.c12
-  });
-  delete globalThis.defineSilgiConfig;
-  const options = klona(loadedConfig.config);
-  options._config = configOverrides;
-  options._c12 = loadedConfig;
-  const _presetName = (loadedConfig.layers || []).find((l) => l.config?._meta?.name)?.config?._meta?.name || presetOverride;
-  options.preset = _presetName;
-  options.compatibilityDate = resolveCompatibilityDates(
-    compatibilityDate,
-    options.compatibilityDate
-  );
-  return options;
-}
-
-export { loadOptions };

package/dist/core/config/resolvers/compatibility.mjs

@@ -1,90 +0,0 @@
-import { resolveCompatibilityDatesFromEnv, formatDate } from 'compatx';
-import consola from 'consola';
-import { colors } from 'consola/utils';
-import { relative } from 'pathe';
-
-const fallbackCompatibilityDate = "2025-02-04";
-async function resolveCompatibilityOptions(options) {
-  options.compatibilityDate = resolveCompatibilityDatesFromEnv(
-    options.compatibilityDate
-  );
-  if (!options.compatibilityDate.default) {
-    options.compatibilityDate.default = await _resolveDefault(options);
-  }
-}
-let _fallbackInfoShown = false;
-let _promptedUserToUpdate = false;
-async function _resolveDefault(options) {
-  const _todayDate = formatDate(/* @__PURE__ */ new Date());
-  const consola$1 = consola.withTag("silgi");
-  consola$1.warn(`No valid compatibility date is specified.`);
-  const onFallback = () => {
-    if (!_fallbackInfoShown) {
-      consola$1.info(
-        [
-          `Using \`${fallbackCompatibilityDate}\` as fallback.`,
-          `  Please specify compatibility date to avoid unwanted behavior changes:`,
-          `     - Add \`compatibilityDate: '${_todayDate}'\` to the config file.`,
-          `     - Or set \`COMPATIBILITY_DATE=${_todayDate}\` environment variable.`,
-          ``
-        ].join("\n")
-      );
-      _fallbackInfoShown = true;
-    }
-    return fallbackCompatibilityDate;
-  };
-  const shallUpdate = !_promptedUserToUpdate && await consola$1.prompt(
-    `Do you want to auto update config file to set ${colors.cyan(`compatibilityDate: '${_todayDate}'`)}?`,
-    {
-      type: "confirm",
-      default: true
-    }
-  );
-  _promptedUserToUpdate = true;
-  if (!shallUpdate) {
-    return onFallback();
-  }
-  const { updateConfig } = await import('c12/update');
-  const updateResult = await updateConfig({
-    configFile: "silgi.config",
-    cwd: options.rootDir,
-    async onCreate({ configFile }) {
-      const shallCreate = await consola$1.prompt(
-        `Do you want to initialize a new config in ${colors.cyan(relative(".", configFile))}?`,
-        {
-          type: "confirm",
-          default: true
-        }
-      );
-      if (shallCreate !== true) {
-        return false;
-      }
-      return _getDefaultNitroConfig();
-    },
-    async onUpdate(config) {
-      config.compatibilityDate = _todayDate;
-    }
-  }).catch((error) => {
-    consola$1.error(`Failed to update config: ${error.message}`);
-    return null;
-  });
-  if (updateResult?.configFile) {
-    consola$1.success(
-      `Compatibility date set to \`${_todayDate}\` in \`${relative(".", updateResult.configFile)}\``
-    );
-    return _todayDate;
-  }
-  return onFallback();
-}
-function _getDefaultNitroConfig() {
-  return (
-    /* js */
-    `
-import { defineSilgiConfig } from 'silgi/config'
-
-export default defineSilgiConfig({})
-  `
-  );
-}
-
-export { fallbackCompatibilityDate, resolveCompatibilityOptions };

package/dist/core/config/resolvers/imports.mjs

@@ -1,96 +0,0 @@
-import escapeRE from 'escape-string-regexp';
-import { resolveModuleExportNames } from 'mlly';
-import { join } from 'pathe';
-
-async function resolveImportsOptions(options) {
-  if (options.imports === false) {
-    return;
-  }
-  options.imports.presets ??= [];
-  options.imports.presets.push(...getSilgiImportsPreset());
-  if (options.preset === "h3") {
-    const h3Exports = await resolveModuleExportNames("h3", {
-      url: import.meta.url
-    });
-    options.imports.presets ??= [];
-    options.imports.presets.push({
-      from: "h3",
-      imports: h3Exports.filter((n) => !/^[A-Z]/.test(n) && n !== "use")
-    });
-  }
-  options.imports.dirs ??= [];
-  options.imports.dirs.push(
-    ...options.scanDirs.map((dir) => join(dir, "utils/**/*"))
-  );
-  if (Array.isArray(options.imports.exclude) && options.imports.exclude.length === 0) {
-    options.imports.exclude.push(/[/\\]\.git[/\\]/);
-    options.imports.exclude.push(options.build.dir);
-    const scanDirsInNodeModules = options.scanDirs.map((dir) => dir.match(/(?<=\/)node_modules\/(.+)$/)?.[1]).filter(Boolean);
-    options.imports.exclude.push(
-      scanDirsInNodeModules.length > 0 ? new RegExp(
-        `node_modules\\/(?!${scanDirsInNodeModules.map((dir) => escapeRE(dir)).join("|")})`
-      ) : /[/\\]node_modules[/\\]/
-    );
-  }
-}
-function getSilgiImportsPreset() {
-  return [
-    // TODO: buraya bizim importlarimiz gelecek.
-    {
-      from: "silgi",
-      imports: [
-        "createShared",
-        "useSilgi",
-        "createService",
-        "createSchema"
-      ]
-    },
-    // {
-    //   from: 'nitropack/runtime',
-    //   imports: ['useRuntimeConfig', 'useAppConfig'],
-    // },
-    // {
-    //   from: 'nitropack/runtime',
-    //   imports: ['defineNitroPlugin', 'nitroPlugin'],
-    // },
-    // {
-    //   from: 'nitropack/runtime/internal/cache',
-    //   imports: [
-    //     'defineCachedFunction',
-    //     'defineCachedEventHandler',
-    //     'cachedFunction',
-    //     'cachedEventHandler',
-    //   ],
-    // },
-    {
-      from: "silgi/core",
-      imports: ["useSilgiStorage"]
-    }
-    // {
-    //   from: 'nitropack/runtime/internal/renderer',
-    //   imports: ['defineRenderHandler'],
-    // },
-    // {
-    //   from: 'nitropack/runtime/internal/meta',
-    //   imports: ['defineRouteMeta'],
-    // },
-    // {
-    //   from: 'nitropack/runtime/internal/route-rules',
-    //   imports: ['getRouteRules'],
-    // },
-    // {
-    //   from: 'nitropack/runtime/internal/context',
-    //   imports: ['useEvent'],
-    // },
-    // {
-    //   from: 'nitropack/runtime/internal/task',
-    //   imports: ['defineTask', 'runTask'],
-    // },
-    // {
-    //   from: 'nitropack/runtime/internal/error/utils',
-    //   imports: ['defineNitroErrorHandler'],
-    // },
-  ];
-}
-
-export { resolveImportsOptions };

package/dist/core/config/resolvers/paths.mjs

@@ -1,194 +0,0 @@
-import { existsSync } from 'node:fs';
-import { pathToFileURL } from 'node:url';
-import { resolvePath as resolvePath$1 } from 'mlly';
-import { resolve, join, isAbsolute } from 'pathe';
-import { findWorkspaceDir, readPackageJSON } from 'pkg-types';
-import { resolveSilgiPath, resolveAlias, resolvePath } from 'silgi/kit';
-import { runtimeDir, pkgDir } from 'silgi/runtime/meta';
-import { isRelative } from 'ufo';
-import { SilgiCLIDefaults } from '../defaults.mjs';
-
-async function resolvePathOptions(options) {
-  options.rootDir = resolve(options.rootDir || ".");
-  options.workspaceDir = await findWorkspaceDir(options.rootDir).catch(
-    () => options.rootDir
-  );
-  options.srcDir = resolve(options.srcDir || options.rootDir);
-  for (const key of ["srcDir"]) {
-    options[key] = resolve(options.rootDir, options[key]);
-  }
-  options.build.dir = resolve(options.rootDir, options.build.dir);
-  options.build.typesDir = resolveSilgiPath(
-    options.build.typesDir || SilgiCLIDefaults.build.typesDir,
-    options,
-    options.rootDir
-  );
-  if (options.preset === "npm-package") {
-    const packageJsonPath = resolve(options.rootDir, "package.json");
-    const packageJson = await readPackageJSON(packageJsonPath);
-    if (packageJson.name === void 0) {
-      throw new Error("Package name is undefined");
-    }
-    options.alias ||= {};
-    options.alias[packageJson.name] = join(options.rootDir, "src/module.ts");
-    options.alias[`${packageJson.name}/runtime/`] = join(options.rootDir, "src/runtime/");
-  }
-  if (options.typescript?.internalPaths || options.stub) {
-    options.alias = {
-      ...options.alias,
-      "silgi/runtime": join(runtimeDir),
-      "#internal/silgi": join(runtimeDir),
-      "silgi/runtime/*": join(runtimeDir, "*"),
-      "#internal/silgi/*": join(runtimeDir, "*")
-    };
-    options.typescript.customConditions = [
-      ...options.typescript.customConditions,
-      "silgiTypes"
-    ];
-    options.conditions ||= [];
-    options.conditions.push("silgi");
-  }
-  options.alias = {
-    ...options.alias,
-    "~/": join(options.srcDir, "/"),
-    "@/": join(options.srcDir, "/"),
-    "~~/": join(options.rootDir, "/"),
-    "@@/": join(options.rootDir, "/")
-  };
-  if (options.preset === "npm-package") {
-    options.alias = {
-      ...options.alias,
-      "#silgi/app/": join(options.build.dir, "/")
-    };
-  }
-  if (options.alias && typeof options.alias === "object") {
-    ((options.typescript.tsConfig ??= {}).compilerOptions ??= {}).paths ??= {};
-    const paths = options.typescript.tsConfig.compilerOptions.paths;
-    for (const [key, value] of Object.entries(options.alias)) {
-      if (typeof paths === "object") {
-        paths[key] = [value];
-      }
-    }
-  }
-  if (options.typescript.tsConfig.compilerOptions?.paths && typeof options.typescript.tsConfig.compilerOptions.paths === "object") {
-    ((options.typescript.tsConfig ??= {}).compilerOptions ??= {}).paths ??= {};
-    const paths = options.typescript.tsConfig.compilerOptions.paths;
-    for (const [key, value] of Object.entries(options.alias)) {
-      if (typeof paths === "object") {
-        paths[key] = [value];
-      }
-    }
-  }
-  options.modulesDir = [resolve(options.rootDir, "node_modules")];
-  options.output.dir = resolveSilgiPath(
-    options.output.dir || SilgiCLIDefaults.output.dir,
-    options,
-    options.rootDir
-  );
-  options.output.publicDir = resolveSilgiPath(
-    options.output.publicDir || SilgiCLIDefaults.output.publicDir,
-    options,
-    options.rootDir
-  );
-  options.output.serverDir = resolveSilgiPath(
-    options.output.serverDir || SilgiCLIDefaults.output.serverDir,
-    options,
-    options.rootDir
-  );
-  options.serverDir = resolveSilgiPath(
-    options.serverDir || SilgiCLIDefaults.serverDir,
-    options,
-    options.rootDir
-  );
-  options.clientDir = resolveSilgiPath(
-    options.clientDir || SilgiCLIDefaults.clientDir,
-    options,
-    options.rootDir
-  );
-  options.silgi.serverDir = resolveSilgiPath(
-    options.silgi.serverDir || SilgiCLIDefaults.silgi.serverDir,
-    options,
-    options.rootDir
-  );
-  options.silgi.clientDir = resolveSilgiPath(
-    options.silgi.clientDir || SilgiCLIDefaults.silgi.clientDir,
-    options,
-    options.rootDir
-  );
-  options.silgi.publicDir = resolveSilgiPath(
-    options.silgi.publicDir || SilgiCLIDefaults.silgi.publicDir,
-    options,
-    options.rootDir
-  );
-  options.silgi.utilsDir = resolveSilgiPath(
-    options.silgi.utilsDir || SilgiCLIDefaults.silgi.utilsDir,
-    options,
-    options.rootDir
-  );
-  options.silgi.vfsDir = resolveSilgiPath(
-    options.silgi.vfsDir || SilgiCLIDefaults.silgi.vfsDir,
-    options,
-    options.rootDir
-  );
-  options.silgi.typesDir = resolveSilgiPath(
-    options.silgi.typesDir || SilgiCLIDefaults.silgi.typesDir,
-    options,
-    options.rootDir
-  );
-  options.nodeModulesDirs.push(resolve(options.workspaceDir, "node_modules"));
-  options.nodeModulesDirs.push(resolve(options.rootDir, "node_modules"));
-  options.nodeModulesDirs.push(resolve(pkgDir, "node_modules"));
-  options.nodeModulesDirs.push(resolve(pkgDir, ".."));
-  options.nodeModulesDirs = [
-    ...new Set(
-      options.nodeModulesDirs.map((dir) => resolve(options.rootDir, dir))
-    )
-  ];
-  options.scanDirs.unshift(options.srcDir);
-  options.scanDirs = options.scanDirs.map(
-    (dir) => resolve(options.srcDir, dir)
-  );
-  options.scanDirs = [...new Set(options.scanDirs)];
-  options.appConfigFiles ??= [];
-  options.appConfigFiles = options.appConfigFiles.map((file) => _tryResolve(resolveSilgiPath(file, options))).filter(Boolean);
-  for (const dir of options.scanDirs) {
-    const configFile = _tryResolve("app.config", dir);
-    if (configFile && !options.appConfigFiles.includes(configFile)) {
-      options.appConfigFiles.push(configFile);
-    }
-  }
-  const modulesRuntimePaths = {};
-  if (options.typescript?.internalPaths) {
-    for (let i of options.modules) {
-      if (typeof i === "string") {
-        i = resolveAlias(i, options.alias);
-        if (isRelative(i)) {
-          i = resolve(options.rootDir, i);
-        }
-        const src = isAbsolute(i) ? pathToFileURL(await resolvePath(i, { fallbackToOriginal: false, extensions: options.extensions })).href : await resolvePath$1(i, { url: options.modulesDir.map((m) => pathToFileURL(m.replace(/\/node_modules\/?$/, ""))), extensions: options.extensions });
-        const cleanPath = src.replace(/(\/(?:src|dist)(?:\/runtime)?(?:\/.*)?$)/, "");
-        modulesRuntimePaths[`${i}/runtime`] = `${cleanPath}/src/runtime`;
-      }
-    }
-    for (const [key, value] of Object.entries(modulesRuntimePaths)) {
-      options.alias = {
-        ...options.alias,
-        [`${key}`]: value
-      };
-    }
-  }
-}
-function _tryResolve(path, base = ".", extensions = ["", ".js", ".ts", ".mjs", ".cjs", ".json"]) {
-  path = resolve(base, path);
-  if (existsSync(path)) {
-    return path;
-  }
-  for (const ext of extensions) {
-    const p = path + ext;
-    if (existsSync(p)) {
-      return p;
-    }
-  }
-}
-
-export { resolvePathOptions };

package/dist/core/config/resolvers/storage.mjs

@@ -1,25 +0,0 @@
-import { resolve } from 'pathe';
-
-async function resolveStorageOptions(options) {
-  const fsMounts = {
-    root: resolve(options.rootDir),
-    src: resolve(options.srcDir),
-    build: resolve(options.build.dir),
-    cache: resolve(options.build.dir, "cache")
-  };
-  for (const p in fsMounts) {
-    options.devStorage[p] = options.devStorage[p] || {
-      driver: "fs",
-      readOnly: p === "root" || p === "src",
-      base: fsMounts[p]
-    };
-  }
-  if (options.dev && options.storage.data === void 0 && options.devStorage.data === void 0) {
-    options.devStorage.data = {
-      driver: "fs",
-      base: resolve(options.rootDir, ".data/kv")
-    };
-  }
-}
-
-export { resolveStorageOptions };

package/dist/core/config/resolvers/url.mjs

@@ -1,7 +0,0 @@
-import { withLeadingSlash, withTrailingSlash } from 'ufo';
-
-async function resolveURLOptions(options) {
-  options.baseURL = withLeadingSlash(withTrailingSlash(options.baseURL));
-}
-
-export { resolveURLOptions };