silgi 0.7.2 → 0.7.4

package/dist/_chunks/index.mjs

@@ -1,4 +1,4 @@
-const version = "0.7.2";
+const version = "0.7.4";
 const packageJson = {
 	version: version};
 

package/dist/cli/config/index.mjs

@@ -1,177 +1,17 @@
-export { l as loadOptions } from '../loader.mjs';
-import { promises, lstatSync } from 'node:fs';
-import { defu } from 'defu';
-import { resolve, dirname, join, isAbsolute, relative } from 'pathe';
-import { readPackageJSON } from 'pkg-types';
-import { relativeWithDot, resolveSilgiModule } from 'silgi/kit';
-import { withTrailingSlash } from 'ufo';
+export { l as loadOptions, s as silgiGenerateType } from '../types.mjs';
 import 'c12';
 import 'compatx';
 import 'klona/full';
 import 'std-env';
 import 'consola';
 import 'consola/utils';
+import 'pathe';
 import 'escape-string-regexp';
 import 'mlly';
+import 'node:fs';
 import 'node:url';
+import 'pkg-types';
+import 'silgi/kit';
 import 'silgi/runtime/meta';
-
-function getDirectory(p) {
-  try {
-    return isAbsolute(p) && lstatSync(p).isFile() ? dirname(p) : p;
-  } catch {
-  }
-  return p;
-}
-function renderAttrs(obj) {
-  const attrs = [];
-  for (const key in obj) {
-    attrs.push(renderAttr(key, obj[key]));
-  }
-  return attrs.join(" ");
-}
-function renderAttr(key, value) {
-  return value ? `${key}="${value}"` : "";
-}
-async function silgiGenerateType(silgi) {
-  const rootDirWithSlash = withTrailingSlash(silgi.options.rootDir);
-  const tsConfigPath = resolve(
-    silgi.options.rootDir,
-    silgi.options.typescript.tsconfigPath
-  );
-  const tsconfigDir = dirname(tsConfigPath);
-  const include = /* @__PURE__ */ new Set([
-    relativeWithDot(tsconfigDir, join(silgi.options.build.typesDir, "silgi.d.ts")).replace(
-      /^(?=[^.])/,
-      "./"
-    ),
-    join(relativeWithDot(tsconfigDir, silgi.options.rootDir), "**/*"),
-    ...silgi.options.srcDir === silgi.options.rootDir ? [] : [join(relativeWithDot(tsconfigDir, silgi.options.srcDir), "**/*")]
-  ]);
-  const exclude = /* @__PURE__ */ new Set([
-    // nitro generate output: https://github.com/nuxt/nuxt/blob/main/packages/nuxt/src/core/nitro.ts#L186
-    relativeWithDot(silgi.options.build.dir, resolve(silgi.options.rootDir, "dist"))
-  ]);
-  for (const dir of silgi.options.modulesDir) {
-    exclude.add(relativeWithDot(silgi.options.build.dir, dir));
-  }
-  const moduleEntryPaths = [];
-  for (const m of silgi.scanModules) {
-    if (m.entryPath) {
-      moduleEntryPaths.push(getDirectory(m.entryPath));
-    }
-  }
-  const modulePaths = await resolveSilgiModule(rootDirWithSlash, moduleEntryPaths);
-  for (const path of modulePaths) {
-    const relative2 = relativeWithDot(silgi.options.build.dir, path);
-    include.add(join(relative2, "runtime"));
-    exclude.add(join(relative2, "runtime/server"));
-    include.add(join(relative2, "dist/runtime"));
-    exclude.add(join(relative2, "dist/runtime/server"));
-  }
-  const tsConfig = defu(silgi.options.typescript?.tsConfig, {
-    compilerOptions: {
-      forceConsistentCasingInFileNames: true,
-      strict: silgi.options.typescript.strict,
-      noEmit: true,
-      target: "ESNext",
-      module: "ESNext",
-      moduleResolution: "Bundler",
-      allowJs: true,
-      resolveJsonModule: true,
-      jsx: "preserve",
-      allowSyntheticDefaultImports: true,
-      jsxFactory: "h",
-      jsxFragmentFactory: "Fragment",
-      allowImportingTsExtensions: true,
-      ...silgi.options.typescript.customConditions ? { customConditions: ["silgiTypes"] } : {},
-      paths: {
-        "#silgiImports": [
-          relativeWithDot(tsconfigDir, join(silgi.options.build.typesDir, "silgi-imports"))
-        ],
-        ...silgi.scanModules.reduce((acc, m) => {
-          if (m.entryPath) {
-            acc[m.meta.name] = [relativeWithDot(tsconfigDir, m.entryPath)];
-          }
-          return acc;
-        }, {}),
-        ...silgi.scanModules.reduce((acc, m) => {
-          if (m.entryPath) {
-            const directory = getDirectory(m.entryPath);
-            acc[`${m.meta.name}/*`] = [`${relativeWithDot(tsconfigDir, directory)}/*`];
-          }
-          return acc;
-        }, {})
-        // ...(silgi.options.typescript?.internalPaths
-        //   ? {
-        //       'silgi/runtime': [
-        //         relativeWithDot(tsconfigDir, join(runtimeDir, 'index')),
-        //       ],
-        //       '#internal/silgi': [
-        //         relativeWithDot(tsconfigDir, join(runtimeDir, 'index')),
-        //       ],
-        //       'silgi/runtime/*': [
-        //         relativeWithDot(tsconfigDir, join(runtimeDir, '*')),
-        //       ],
-        //       '#internal/silgi/*': [
-        //         relativeWithDot(tsconfigDir, join(runtimeDir, '*')),
-        //       ],
-        //     }
-        //   : {}),
-      }
-    },
-    include: [...include],
-    exclude: [...exclude]
-  });
-  tsConfig.compilerOptions ||= {};
-  tsConfig.compilerOptions.paths ||= {};
-  tsConfig.include ||= [];
-  for (const alias in tsConfig.compilerOptions.paths) {
-    const paths = tsConfig.compilerOptions.paths[alias];
-    tsConfig.compilerOptions.paths[alias] = await Promise.all(
-      paths.map(async (path) => {
-        if (!isAbsolute(path)) {
-          return path;
-        }
-        const stats = await promises.stat(path).catch(
-          () => null
-          /* file does not exist */
-        );
-        return relativeWithDot(
-          tsconfigDir,
-          stats?.isFile() ? path.replace(/\b\.\w+$/g, "") : path
-        );
-      })
-    );
-  }
-  const references = [];
-  await Promise.all([...silgi.options.modules, ...silgi.options._modules].map(async (id) => {
-    if (typeof id !== "string") {
-      return;
-    }
-    const pkg = await readPackageJSON(id, { url: silgi.options.modulesDir }).catch(() => null);
-    references.push({ types: pkg?.name || id });
-  }));
-  const declarations = [];
-  await silgi.callHook("prepare:types", { references, declarations, tsConfig });
-  tsConfig.include = [...new Set(tsConfig.include.map((p) => isAbsolute(p) ? relativeWithDot(silgi.options.build.dir, p) : p))];
-  tsConfig.exclude = [...new Set(tsConfig.exclude.map((p) => isAbsolute(p) ? relativeWithDot(silgi.options.build.dir, p) : p))];
-  const _declarations = [
-    ...references.map((ref) => {
-      if ("path" in ref && isAbsolute(ref.path)) {
-        ref.path = relative(silgi.options.build.dir, ref.path);
-      }
-      return `/// <reference ${renderAttrs(ref)} />`;
-    }),
-    ...declarations,
-    "",
-    "export {}",
-    ""
-  ];
-  return {
-    declarations: _declarations,
-    tsConfig
-  };
-}
-
-export { silgiGenerateType };
+import 'ufo';
+import 'defu';

package/dist/cli/prepare.mjs

@@ -2,34 +2,36 @@ import { defineCommand } from 'citty';
 import { join, resolve, isAbsolute, relative, dirname, basename, extname } from 'pathe';
 import { version } from 'silgi/meta';
 import { runtimeDir } from 'silgi/runtime/meta';
-import { promises, existsSync, readFileSync, mkdirSync, writeFileSync } from 'node:fs';
+import { promises, existsSync, readFileSync, writeFileSync, mkdirSync } from 'node:fs';
 import { readdir } from 'node:fs/promises';
 import { resolvePath, parseNodeModulePath, lookupNodeModuleSubpath, resolve as resolve$1 } from 'mlly';
 import { resolveAlias } from 'pathe/utils';
-import { silgiGenerateType, useSilgiCLI, SchemaParser, silgiCLICtx } from 'silgi/core';
 import { relativeWithDot, isDirectory, writeFile, resolveAlias as resolveAlias$1, resolvePath as resolvePath$1, normalizeTemplate, useLogger } from 'silgi/kit';
 import { toExports, scanExports, createUnimport } from 'unimport';
 import { createJiti } from 'dev-jiti';
 import { readPackageJSON } from 'pkg-types';
 import { hash } from 'ohash';
+import { s as silgiGenerateType, l as loadOptions } from './types.mjs';
 import { consola } from 'consola';
 import { createHooks, createDebugger } from 'hookable';
+import { useSilgiCLI, silgiCLICtx } from 'silgi/core';
 import { pascalCase } from 'scule';
 import { h as hasInstalledModule } from './compatibility.mjs';
 import { pathToFileURL, fileURLToPath } from 'node:url';
 import { isRelative, withTrailingSlash } from 'ufo';
 import { globby } from 'globby';
 import ignore from 'ignore';
+import { parseSync } from '@oxc-parser/wasm';
 import { klona } from 'klona';
 import { createStorage, builtinDrivers } from 'unstorage';
-import { l as loadOptions } from './loader.mjs';
-import 'semver/functions/satisfies.js';
 import 'c12';
 import 'compatx';
 import 'klona/full';
 import 'std-env';
 import 'consola/utils';
 import 'escape-string-regexp';
+import 'defu';
+import 'semver/functions/satisfies.js';
 
 async function h3Framework(silgi, skip = false) {
   if (silgi.options.preset !== "h3" && skip === false)
@@ -1081,6 +1083,138 @@ function resolveGroupSyntax(group) {
   return groups;
 }
 
+class SchemaParser {
+  options = {
+    debug: false
+  };
+  /**
+   *
+   */
+  constructor(options) {
+    this.options = {
+      ...this.options,
+      ...options
+    };
+  }
+  parseExports(content, filePath) {
+    const ast = parseSync(content, { sourceType: "module", sourceFilename: filePath });
+    if (this.options.debug)
+      writeFileSync(`${filePath}.ast.json`, JSON.stringify(ast.program, null, 2));
+    return {
+      exportVariables: (search, path) => this.parseTypeDeclarations(ast, search, path),
+      parseInterfaceDeclarations: (search, path) => this.parseInterfaceDeclarations(ast, search, path)
+      // parsePlugin: (path: string) => this.parsePlugin(ast, path),
+    };
+  }
+  parseVariableDeclaration(ast) {
+    return ast.program.body.filter((i) => i.type === "ExportNamedDeclaration").filter((i) => i.declaration?.type === "VariableDeclaration");
+  }
+  parseTSInterfaceDeclaration(ast) {
+    return ast.program.body.filter((i) => i.type === "ExportNamedDeclaration").filter((i) => i.declaration?.type === "TSInterfaceDeclaration");
+  }
+  parseTypeDeclarations(ast, find = "", path = "") {
+    const data = [];
+    for (const item of this.parseVariableDeclaration(ast)) {
+      for (const declaration of item.declaration.declarations) {
+        if (declaration.init?.callee?.name === find) {
+          const options = {};
+          if (declaration.init.arguments) {
+            for (const argument of declaration.init.arguments) {
+              for (const propertie of argument.properties) {
+                if (propertie.key.name === "name")
+                  options.pluginName = propertie.value.value;
+              }
+            }
+          }
+          for (const key in declaration.init.properties) {
+            const property = declaration.init.properties[key];
+            if (property.type === "ObjectProperty") {
+              if (property.key.name === "options") {
+                for (const key2 in property.value.properties) {
+                  const option = property.value.properties[key2];
+                  if (option.type === "ObjectProperty") {
+                    options[option.key.name] = option.value.value;
+                  }
+                }
+              }
+            }
+          }
+          options.type = false;
+          data.push({
+            exportName: declaration.id.name,
+            options,
+            // object: declaration.init,
+            path
+          });
+        }
+      }
+    }
+    return data;
+  }
+  parseInterfaceDeclarations(ast, find = "", path = "") {
+    const data = [];
+    for (const item of this.parseTSInterfaceDeclaration(ast)) {
+      if (!item?.declaration?.extends)
+        continue;
+      for (const declaration of item?.declaration?.extends) {
+        if (declaration.expression.name === find) {
+          const options = {};
+          options.type = true;
+          data.push({
+            exportName: item.declaration.id.name,
+            options,
+            // object: declaration.init,
+            path
+          });
+        }
+      }
+    }
+    return data;
+  }
+  // private parsePlugin(ast: any, path: string = '') {
+  //   const data = {
+  //     export: [],
+  //     name: '',
+  //     path: '',
+  //   } as DataTypePlugin
+  //   for (const item of this.parseVariableDeclaration(ast)) {
+  //     for (const declaration of item.declaration.declarations) {
+  //       if (declaration.init.callee?.name === 'defineSilgiModule') {
+  //         if (declaration.init.arguments) {
+  //           for (const argument of declaration.init.arguments) {
+  //             for (const propertie of argument.properties) {
+  //               if (propertie.key.name === 'name')
+  //                 data.name = propertie.value.value
+  //             }
+  //           }
+  //         }
+  //         data.export.push({
+  //           name: data.name,
+  //           as: camelCase(`${data.name}DefineSilgiModule`),
+  //           type: false,
+  //         })
+  //       }
+  //     }
+  //   }
+  //   for (const item of this.parseTSInterfaceDeclaration(ast)) {
+  //     if (!item?.declaration?.extends)
+  //       continue
+  //     for (const declaration of item?.declaration?.extends) {
+  //       if (declaration.expression.name === 'ModuleOptions') {
+  //         data.export.push({
+  //           name: item.declaration.id.name,
+  //           as: camelCase(`${data.name}ModuleOptions`),
+  //           type: true,
+  //         })
+  //       }
+  //       // TODO add other plugins
+  //     }
+  //   }
+  //   data.path = path
+  //   return data
+  // }
+}
+
 async function scanFiles$1(silgi) {
   const filePaths = /* @__PURE__ */ new Set();
   const scannedPaths = [];

package/dist/cli/{loader.mjs → types.mjs}

@@ -4,15 +4,16 @@ import { klona } from 'klona/full';
 import { isDebug, isTest } from 'std-env';
 import consola from 'consola';
 import { colors } from 'consola/utils';
-import { relative, join, resolve, isAbsolute } from 'pathe';
+import { relative, join, resolve, isAbsolute, dirname } from 'pathe';
 import escapeRE from 'escape-string-regexp';
 import { resolveModuleExportNames, resolvePath as resolvePath$1 } from 'mlly';
-import { existsSync } from 'node:fs';
+import { existsSync, promises, lstatSync } from 'node:fs';
 import { pathToFileURL } from 'node:url';
 import { findWorkspaceDir, readPackageJSON } from 'pkg-types';
-import { resolveSilgiPath, resolveAlias, resolvePath } from 'silgi/kit';
+import { resolveSilgiPath, resolveAlias, resolvePath, relativeWithDot, resolveSilgiModule } from 'silgi/kit';
 import { runtimeDir, pkgDir } from 'silgi/runtime/meta';
 import { isRelative, withLeadingSlash, withTrailingSlash } from 'ufo';
+import { defu } from 'defu';
 
 const SilgiCLIDefaults = {
   // General
@@ -578,4 +579,162 @@ async function _loadUserConfig(configOverrides = {}, opts = {}) {
   return options;
 }
 
-export { loadOptions as l };
+function getDirectory(p) {
+  try {
+    return isAbsolute(p) && lstatSync(p).isFile() ? dirname(p) : p;
+  } catch {
+  }
+  return p;
+}
+function renderAttrs(obj) {
+  const attrs = [];
+  for (const key in obj) {
+    attrs.push(renderAttr(key, obj[key]));
+  }
+  return attrs.join(" ");
+}
+function renderAttr(key, value) {
+  return value ? `${key}="${value}"` : "";
+}
+async function silgiGenerateType(silgi) {
+  const rootDirWithSlash = withTrailingSlash(silgi.options.rootDir);
+  const tsConfigPath = resolve(
+    silgi.options.rootDir,
+    silgi.options.typescript.tsconfigPath
+  );
+  const tsconfigDir = dirname(tsConfigPath);
+  const include = /* @__PURE__ */ new Set([
+    relativeWithDot(tsconfigDir, join(silgi.options.build.typesDir, "silgi.d.ts")).replace(
+      /^(?=[^.])/,
+      "./"
+    ),
+    join(relativeWithDot(tsconfigDir, silgi.options.rootDir), "**/*"),
+    ...silgi.options.srcDir === silgi.options.rootDir ? [] : [join(relativeWithDot(tsconfigDir, silgi.options.srcDir), "**/*")]
+  ]);
+  const exclude = /* @__PURE__ */ new Set([
+    // nitro generate output: https://github.com/nuxt/nuxt/blob/main/packages/nuxt/src/core/nitro.ts#L186
+    relativeWithDot(silgi.options.build.dir, resolve(silgi.options.rootDir, "dist"))
+  ]);
+  for (const dir of silgi.options.modulesDir) {
+    exclude.add(relativeWithDot(silgi.options.build.dir, dir));
+  }
+  const moduleEntryPaths = [];
+  for (const m of silgi.scanModules) {
+    if (m.entryPath) {
+      moduleEntryPaths.push(getDirectory(m.entryPath));
+    }
+  }
+  const modulePaths = await resolveSilgiModule(rootDirWithSlash, moduleEntryPaths);
+  for (const path of modulePaths) {
+    const relative2 = relativeWithDot(silgi.options.build.dir, path);
+    include.add(join(relative2, "runtime"));
+    exclude.add(join(relative2, "runtime/server"));
+    include.add(join(relative2, "dist/runtime"));
+    exclude.add(join(relative2, "dist/runtime/server"));
+  }
+  const tsConfig = defu(silgi.options.typescript?.tsConfig, {
+    compilerOptions: {
+      forceConsistentCasingInFileNames: true,
+      strict: silgi.options.typescript.strict,
+      noEmit: true,
+      target: "ESNext",
+      module: "ESNext",
+      moduleResolution: "Bundler",
+      allowJs: true,
+      resolveJsonModule: true,
+      jsx: "preserve",
+      allowSyntheticDefaultImports: true,
+      jsxFactory: "h",
+      jsxFragmentFactory: "Fragment",
+      allowImportingTsExtensions: true,
+      ...silgi.options.typescript.customConditions ? { customConditions: ["silgiTypes"] } : {},
+      paths: {
+        "#silgiImports": [
+          relativeWithDot(tsconfigDir, join(silgi.options.build.typesDir, "silgi-imports"))
+        ],
+        ...silgi.scanModules.reduce((acc, m) => {
+          if (m.entryPath) {
+            acc[m.meta.name] = [relativeWithDot(tsconfigDir, m.entryPath)];
+          }
+          return acc;
+        }, {}),
+        ...silgi.scanModules.reduce((acc, m) => {
+          if (m.entryPath) {
+            const directory = getDirectory(m.entryPath);
+            acc[`${m.meta.name}/*`] = [`${relativeWithDot(tsconfigDir, directory)}/*`];
+          }
+          return acc;
+        }, {})
+        // ...(silgi.options.typescript?.internalPaths
+        //   ? {
+        //       'silgi/runtime': [
+        //         relativeWithDot(tsconfigDir, join(runtimeDir, 'index')),
+        //       ],
+        //       '#internal/silgi': [
+        //         relativeWithDot(tsconfigDir, join(runtimeDir, 'index')),
+        //       ],
+        //       'silgi/runtime/*': [
+        //         relativeWithDot(tsconfigDir, join(runtimeDir, '*')),
+        //       ],
+        //       '#internal/silgi/*': [
+        //         relativeWithDot(tsconfigDir, join(runtimeDir, '*')),
+        //       ],
+        //     }
+        //   : {}),
+      }
+    },
+    include: [...include],
+    exclude: [...exclude]
+  });
+  tsConfig.compilerOptions ||= {};
+  tsConfig.compilerOptions.paths ||= {};
+  tsConfig.include ||= [];
+  for (const alias in tsConfig.compilerOptions.paths) {
+    const paths = tsConfig.compilerOptions.paths[alias];
+    tsConfig.compilerOptions.paths[alias] = await Promise.all(
+      paths.map(async (path) => {
+        if (!isAbsolute(path)) {
+          return path;
+        }
+        const stats = await promises.stat(path).catch(
+          () => null
+          /* file does not exist */
+        );
+        return relativeWithDot(
+          tsconfigDir,
+          stats?.isFile() ? path.replace(/\b\.\w+$/g, "") : path
+        );
+      })
+    );
+  }
+  const references = [];
+  await Promise.all([...silgi.options.modules, ...silgi.options._modules].map(async (id) => {
+    if (typeof id !== "string") {
+      return;
+    }
+    const pkg = await readPackageJSON(id, { url: silgi.options.modulesDir }).catch(() => null);
+    references.push({ types: pkg?.name || id });
+  }));
+  const declarations = [];
+  await silgi.callHook("prepare:types", { references, declarations, tsConfig });
+  tsConfig.include = [...new Set(tsConfig.include.map((p) => isAbsolute(p) ? relativeWithDot(silgi.options.build.dir, p) : p))];
+  tsConfig.exclude = [...new Set(tsConfig.exclude.map((p) => isAbsolute(p) ? relativeWithDot(silgi.options.build.dir, p) : p))];
+  const _declarations = [
+    ...references.map((ref) => {
+      if ("path" in ref && isAbsolute(ref.path)) {
+        ref.path = relative(silgi.options.build.dir, ref.path);
+      }
+      return `/// <reference ${renderAttrs(ref)} />`;
+    }),
+    ...declarations,
+    "",
+    "export {}",
+    ""
+  ];
+  return {
+    declarations: _declarations,
+    tsConfig
+  };
+}
+
+export { loadOptions as l, silgiGenerateType as s };

package/dist/core/index.d.mts

@@ -37,33 +37,6 @@ type SilgiFetchOptions<R extends ValidRoute, M extends Method<R>> = {
 type SilgiFetchClient = <R extends ValidRoute, M extends Method<R> = 'get' extends Method<R> ? 'get' : Method<R>>(url: R, options: SilgiFetchOptions<R, M>) => Promise<FetchResponseData<R, M>>;
 declare function createSilgiFetch(options: FetchOptions | ((options: FetchOptions) => FetchOptions), localFetch?: typeof globalThis.$fetch): SilgiFetchClient;
 
-interface Options {
-    debug?: boolean;
-}
-interface DataType {
-    exportName: string;
-    options: {
-        type: boolean;
-        pluginName?: string;
-    };
-    path: string;
-}
-declare class SchemaParser {
-    options: Options;
-    /**
-     *
-     */
-    constructor(options?: Options);
-    parseExports(content: string, filePath: string): {
-        exportVariables: (search: string, path: string) => DataType[];
-        parseInterfaceDeclarations: (search: string, path: string) => DataType[];
-    };
-    private parseVariableDeclaration;
-    private parseTSInterfaceDeclaration;
-    private parseTypeDeclarations;
-    private parseInterfaceDeclarations;
-}
-
 interface RouteTemplateValidator {
     (value: string): boolean;
 }
@@ -311,4 +284,4 @@ declare function useSilgiCLI(): SilgiCLI;
  */
 declare function tryUseSilgiCLI(): SilgiCLI | null;
 
-export { type BaseError, ErrorCategory, ErrorFactory, type ErrorMetadata, ErrorSeverity, HttpStatus, SchemaParser, SilgiError, createSchema, createService, createShared, createSilgi, createSilgiFetch, getEvent, isBaseError, mergeSchemas, mergeServices, mergeShared, parseURI, silgiCLICtx, silgiCtx, tryUseSilgi, tryUseSilgiCLI, useSilgi, useSilgiCLI };
+export { type BaseError, ErrorCategory, ErrorFactory, type ErrorMetadata, ErrorSeverity, HttpStatus, SilgiError, createSchema, createService, createShared, createSilgi, createSilgiFetch, getEvent, isBaseError, mergeSchemas, mergeServices, mergeShared, parseURI, silgiCLICtx, silgiCtx, tryUseSilgi, tryUseSilgiCLI, useSilgi, useSilgiCLI };

package/dist/core/index.d.ts

@@ -37,33 +37,6 @@ type SilgiFetchOptions<R extends ValidRoute, M extends Method<R>> = {
 type SilgiFetchClient = <R extends ValidRoute, M extends Method<R> = 'get' extends Method<R> ? 'get' : Method<R>>(url: R, options: SilgiFetchOptions<R, M>) => Promise<FetchResponseData<R, M>>;
 declare function createSilgiFetch(options: FetchOptions | ((options: FetchOptions) => FetchOptions), localFetch?: typeof globalThis.$fetch): SilgiFetchClient;
 
-interface Options {
-    debug?: boolean;
-}
-interface DataType {
-    exportName: string;
-    options: {
-        type: boolean;
-        pluginName?: string;
-    };
-    path: string;
-}
-declare class SchemaParser {
-    options: Options;
-    /**
-     *
-     */
-    constructor(options?: Options);
-    parseExports(content: string, filePath: string): {
-        exportVariables: (search: string, path: string) => DataType[];
-        parseInterfaceDeclarations: (search: string, path: string) => DataType[];
-    };
-    private parseVariableDeclaration;
-    private parseTSInterfaceDeclaration;
-    private parseTypeDeclarations;
-    private parseInterfaceDeclarations;
-}
-
 interface RouteTemplateValidator {
     (value: string): boolean;
 }
@@ -311,4 +284,4 @@ declare function useSilgiCLI(): SilgiCLI;
  */
 declare function tryUseSilgiCLI(): SilgiCLI | null;
 
-export { type BaseError, ErrorCategory, ErrorFactory, type ErrorMetadata, ErrorSeverity, HttpStatus, SchemaParser, SilgiError, createSchema, createService, createShared, createSilgi, createSilgiFetch, getEvent, isBaseError, mergeSchemas, mergeServices, mergeShared, parseURI, silgiCLICtx, silgiCtx, tryUseSilgi, tryUseSilgiCLI, useSilgi, useSilgiCLI };
+export { type BaseError, ErrorCategory, ErrorFactory, type ErrorMetadata, ErrorSeverity, HttpStatus, SilgiError, createSchema, createService, createShared, createSilgi, createSilgiFetch, getEvent, isBaseError, mergeSchemas, mergeServices, mergeShared, parseURI, silgiCLICtx, silgiCtx, tryUseSilgi, tryUseSilgiCLI, useSilgi, useSilgiCLI };

package/dist/core/index.mjs

@@ -9,8 +9,6 @@ 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 { writeFileSync } from 'node:fs';
-import { parseSync } from '@oxc-parser/wasm';
 
 const common = defineUntypedSchema({
   /**
@@ -648,138 +646,6 @@ function fillPath(path, params) {
   return result;
 }
 
-class SchemaParser {
-  options = {
-    debug: false
-  };
-  /**
-   *
-   */
-  constructor(options) {
-    this.options = {
-      ...this.options,
-      ...options
-    };
-  }
-  parseExports(content, filePath) {
-    const ast = parseSync(content, { sourceType: "module", sourceFilename: filePath });
-    if (this.options.debug)
-      writeFileSync(`${filePath}.ast.json`, JSON.stringify(ast.program, null, 2));
-    return {
-      exportVariables: (search, path) => this.parseTypeDeclarations(ast, search, path),
-      parseInterfaceDeclarations: (search, path) => this.parseInterfaceDeclarations(ast, search, path)
-      // parsePlugin: (path: string) => this.parsePlugin(ast, path),
-    };
-  }
-  parseVariableDeclaration(ast) {
-    return ast.program.body.filter((i) => i.type === "ExportNamedDeclaration").filter((i) => i.declaration?.type === "VariableDeclaration");
-  }
-  parseTSInterfaceDeclaration(ast) {
-    return ast.program.body.filter((i) => i.type === "ExportNamedDeclaration").filter((i) => i.declaration?.type === "TSInterfaceDeclaration");
-  }
-  parseTypeDeclarations(ast, find = "", path = "") {
-    const data = [];
-    for (const item of this.parseVariableDeclaration(ast)) {
-      for (const declaration of item.declaration.declarations) {
-        if (declaration.init?.callee?.name === find) {
-          const options = {};
-          if (declaration.init.arguments) {
-            for (const argument of declaration.init.arguments) {
-              for (const propertie of argument.properties) {
-                if (propertie.key.name === "name")
-                  options.pluginName = propertie.value.value;
-              }
-            }
-          }
-          for (const key in declaration.init.properties) {
-            const property = declaration.init.properties[key];
-            if (property.type === "ObjectProperty") {
-              if (property.key.name === "options") {
-                for (const key2 in property.value.properties) {
-                  const option = property.value.properties[key2];
-                  if (option.type === "ObjectProperty") {
-                    options[option.key.name] = option.value.value;
-                  }
-                }
-              }
-            }
-          }
-          options.type = false;
-          data.push({
-            exportName: declaration.id.name,
-            options,
-            // object: declaration.init,
-            path
-          });
-        }
-      }
-    }
-    return data;
-  }
-  parseInterfaceDeclarations(ast, find = "", path = "") {
-    const data = [];
-    for (const item of this.parseTSInterfaceDeclaration(ast)) {
-      if (!item?.declaration?.extends)
-        continue;
-      for (const declaration of item?.declaration?.extends) {
-        if (declaration.expression.name === find) {
-          const options = {};
-          options.type = true;
-          data.push({
-            exportName: item.declaration.id.name,
-            options,
-            // object: declaration.init,
-            path
-          });
-        }
-      }
-    }
-    return data;
-  }
-  // private parsePlugin(ast: any, path: string = '') {
-  //   const data = {
-  //     export: [],
-  //     name: '',
-  //     path: '',
-  //   } as DataTypePlugin
-  //   for (const item of this.parseVariableDeclaration(ast)) {
-  //     for (const declaration of item.declaration.declarations) {
-  //       if (declaration.init.callee?.name === 'defineSilgiModule') {
-  //         if (declaration.init.arguments) {
-  //           for (const argument of declaration.init.arguments) {
-  //             for (const propertie of argument.properties) {
-  //               if (propertie.key.name === 'name')
-  //                 data.name = propertie.value.value
-  //             }
-  //           }
-  //         }
-  //         data.export.push({
-  //           name: data.name,
-  //           as: camelCase(`${data.name}DefineSilgiModule`),
-  //           type: false,
-  //         })
-  //       }
-  //     }
-  //   }
-  //   for (const item of this.parseTSInterfaceDeclaration(ast)) {
-  //     if (!item?.declaration?.extends)
-  //       continue
-  //     for (const declaration of item?.declaration?.extends) {
-  //       if (declaration.expression.name === 'ModuleOptions') {
-  //         data.export.push({
-  //           name: item.declaration.id.name,
-  //           as: camelCase(`${data.name}ModuleOptions`),
-  //           type: true,
-  //         })
-  //       }
-  //       // TODO add other plugins
-  //     }
-  //   }
-  //   data.path = path
-  //   return data
-  // }
-}
-
 function silgi(event) {
   return {
     execute: (uriString, input) => {
@@ -940,4 +806,4 @@ function tryUseSilgiCLI() {
   return silgiCLICtx.tryUse();
 }
 
-export { ErrorCategory, ErrorFactory, ErrorSeverity, HttpStatus, SchemaParser, SilgiError, createSchema, createService, createShared, createSilgi, createSilgiFetch, createStorage, getEvent, isBaseError, mergeSchemas, mergeServices, mergeShared, parseURI, silgi, silgiCLICtx, silgiCtx, tryUseSilgi, tryUseSilgiCLI, useSilgi, useSilgiCLI, useSilgiStorage };
+export { ErrorCategory, ErrorFactory, ErrorSeverity, HttpStatus, SilgiError, createSchema, createService, createShared, createSilgi, createSilgiFetch, createStorage, getEvent, isBaseError, mergeSchemas, mergeServices, mergeShared, parseURI, silgi, silgiCLICtx, silgiCtx, tryUseSilgi, tryUseSilgiCLI, useSilgi, useSilgiCLI, useSilgiStorage };

package/dist/meta/index.d.mts

@@ -1,3 +1,3 @@
-const version = "0.7.2";
+const version = "0.7.4";
 
 export { version };

package/dist/meta/index.d.ts

@@ -1,3 +1,3 @@
-const version = "0.7.2";
+const version = "0.7.4";
 
 export { version };

package/dist/presets/_resolve.d.ts

@@ -1,5 +1,5 @@
+import type { CompatibilityDateSpec } from 'compatx';
 import type { SilgiPreset, SilgiPresetMeta } from 'silgi/types';
-import { type CompatibilityDateSpec } from 'compatx';
 export declare function resolvePreset(name: string, opts: {
     static?: boolean;
     compatibilityDate?: false | CompatibilityDateSpec;

package/dist/runtime/internal/nuxt.d.ts

@@ -1,6 +1,6 @@
+import type { AsyncData, UseFetchOptions } from 'nuxt/app';
 import type { FetchError } from 'ofetch';
 import type { SilgiRouterTypes } from 'silgi/types';
-import { type AsyncData, type UseFetchOptions } from 'nuxt/app';
 type TrimAfterFourSlashes<T extends string> = T extends `/${infer S1}/${infer S2}/${infer S3}/${infer S4}/${infer _}` ? `/${S1}/${S2}/${S3}/${S4}` : T;
 type AllPaths = SilgiRouterTypes extends {
     keys: infer U;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "silgi",
   "type": "module",
-  "version": "0.7.2",
+  "version": "0.7.4",
   "private": false,
   "sideEffects": false,
   "exports": {