silgi 0.29.22 → 0.29.24

package/dist/cli/dev.mjs

@@ -6,7 +6,7 @@ import { join } from 'pathe';
 import { useSilgiCLI } from 'silgi';
 import { version } from 'silgi/meta';
 import { a as silgiCLIIClose } from '../_chunks/silgiApp.mjs';
-import { c as commonArgs, p as prepare } from './prepare.mjs';
+import { b as commonArgs, a as command$1 } from './prepare.mjs';
 import 'unctx';
 import './silgi.mjs';
 import 'apiful/openapi';
@@ -52,7 +52,7 @@ async function reloadScan(path, _stats) {
   await silgi.callHook("reload:scan", path, _stats);
 }
 
-const dev = defineCommand({
+const command = defineCommand({
   meta: {
     name: "dev",
     description: "Start the development server for the project",
@@ -70,7 +70,7 @@ const dev = defineCommand({
     }
   },
   async run() {
-    await runCommand(prepare, {
+    await runCommand(command$1, {
       rawArgs: ["--commandType", "dev", "--dev", "true"]
     });
     const silgi = useSilgiCLI();
@@ -103,7 +103,7 @@ const dev = defineCommand({
         silgi.errors = [];
         try {
           await reloadScan(path, stats);
-          await runCommand(prepare, {
+          await runCommand(command$1, {
             rawArgs: ["--commands", "run", "--dev", "true"]
           });
         } catch (error) {
@@ -132,4 +132,4 @@ const dev = defineCommand({
   }
 });
 
-export { dev as default };
+export { command as default };

package/dist/cli/index.mjs

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import { defineCommand, runMain } from 'citty';
 
-const version = "0.29.22";
+const version = "0.29.24";
 const packageJson = {
 	version: version};
 
@@ -18,7 +18,7 @@ const main = defineCommand({
     }
   },
   subCommands: {
-    prepare: () => import('./prepare.mjs').then(function (n) { return n.a; }).then((m) => m.default),
+    prepare: () => import('./prepare.mjs').then(function (n) { return n.p; }).then((m) => m.default),
     init: () => import('./init.mjs').then((m) => m.default),
     run: () => import('./prepare.mjs').then(function (n) { return n.r; }).then((m) => m.default),
     install: () => import('./install.mjs').then((m) => m.default),

package/dist/cli/init.mjs

@@ -4,11 +4,11 @@ import * as p from '@clack/prompts';
 import { defineCommand, runCommand } from 'citty';
 import consola from 'consola';
 import { dirname } from 'pathe';
-import { p as prepare } from './prepare.mjs';
+import { isPresents } from 'silgi/kit';
+import { c as cancelOnCancel, a as command$1 } from './prepare.mjs';
 import 'silgi/meta';
 import './silgi.mjs';
 import 'apiful/openapi';
-import 'silgi/kit';
 import 'knitwork';
 import 'mlly';
 import 'pathe/utils';
@@ -45,7 +45,7 @@ import 'node:child_process';
 import '../_chunks/silgiApp.mjs';
 import 'unctx';
 
-const init = defineCommand({
+const command = defineCommand({
   meta: {
     name: "Silgi Init",
     description: "Initialize silgi config",
@@ -61,12 +61,10 @@ const init = defineCommand({
         { label: "Nuxt", value: "nuxt" },
         { label: "H3", value: "h3" },
         { label: "NPM Package", value: "npm-package" }
-      ]
+      ],
+      initialValue: "h3"
     });
-    if (p.isCancel(framework)) {
-      consola.info("Silgi config initialization canceled");
-      return;
-    }
+    cancelOnCancel({ value: framework });
     const context = [
       `import { defineSilgiConfig } from 'silgi/config'`,
       "",
@@ -79,20 +77,19 @@ const init = defineCommand({
       "})",
       ""
     ];
-    if (framework === "nitro" || framework === "nuxt") {
+    if (isPresents(["nitro", "nuxt"])) {
       const plugin = [
         `import { buildSilgi } from '../silgi/core'`,
         "",
         "export default defineNitroPlugin(async (nitro) => {",
         "",
-        "  const _silgi = buildSilgi(",
-        "    nitro,",
-        "    {},",
-        "    {",
+        "  await buildSilgi({",
+        "    framework: nitro,",
+        "    options: {",
         "      putStorage: useStorage(),",
         "      runtimeConfig: useRuntimeConfig(),",
         "    },",
-        "  )",
+        "  })",
         "})",
         ""
       ];
@@ -100,7 +97,7 @@ const init = defineCommand({
       await fsp.mkdir(dirname(file), { recursive: true });
       writeFileSync(file, plugin.join("\n"));
       consola.success("Silgi plugin created, see server/plugins/silgi.ts");
-      runCommand(prepare, {
+      runCommand(command$1, {
         rawArgs: ["--env", ".env"]
       });
     }
@@ -109,4 +106,4 @@ const init = defineCommand({
   }
 });
 
-export { init as default };
+export { command as default };

package/dist/cli/install.mjs

@@ -4,7 +4,7 @@ import { consola } from 'consola';
 import { version } from 'silgi/meta';
 import { addNPMPackage, addTemplate } from 'silgi/kit';
 import { u as useSilgiCLI } from '../_chunks/silgiApp.mjs';
-import { c as commonArgs, p as prepare } from './prepare.mjs';
+import { b as commonArgs, a as command$1 } from './prepare.mjs';
 import 'unctx';
 import 'pathe';
 import './silgi.mjs';
@@ -90,7 +90,7 @@ async function installPackages(silgi = useSilgiCLI()) {
   return packages;
 }
 
-const install = defineCommand({
+const command = defineCommand({
   meta: {
     name: "install",
     description: "Install dependencies from the install.json file.",
@@ -104,7 +104,7 @@ const install = defineCommand({
     }
   },
   async run() {
-    await runCommand(prepare, {
+    await runCommand(command$1, {
       rawArgs: ["--commandType", "install"]
     }).catch(() => {
     });
@@ -133,4 +133,4 @@ const install = defineCommand({
   }
 });
 
-export { install as default };
+export { command as default };

package/dist/cli/prepare.mjs

@@ -44,7 +44,7 @@ async function scanCommands(silgi = useSilgiCLI()) {
       getContents: () => JSON.stringify(commands, null, 2)
     });
   }
-  silgi.hook("prepare:schema.ts", async (object) => {
+  silgi.hook("before:schema.ts", async () => {
     const allTags = commands.reduce((acc, commandGroup) => {
       Object.values(commandGroup).forEach((command) => {
         if (command.tags) {
@@ -71,7 +71,12 @@ async function scanCommands(silgi = useSilgiCLI()) {
       ),
       ""
     ];
-    object.customImports?.push(...data);
+    addTemplate({
+      filename: "types/commands.d.ts",
+      write: true,
+      where: ".silgi",
+      getContents: () => data.join("\n")
+    });
   });
   return commands;
 }
@@ -91,7 +96,7 @@ function cancelOnCancel({
     handleCancel();
 }
 
-const run = defineCommand({
+const command$1 = defineCommand({
   meta: {
     name: "run",
     description: "Run a command from the CLI",
@@ -114,7 +119,7 @@ const run = defineCommand({
   },
   async run({ args }) {
     if (args.prepare) {
-      await runCommand(prepare, {
+      await runCommand(command, {
         rawArgs: ["--commandType", "run"]
       });
     }
@@ -189,12 +194,12 @@ const run = defineCommand({
   }
 });
 
-const run$1 = {
+const run = {
   __proto__: null,
-  default: run
+  default: command$1
 };
 
-const prepare = defineCommand({
+const command = defineCommand({
   meta: {
     name: "prepare",
     description: "Generate types for the project",
@@ -235,16 +240,16 @@ const prepare = defineCommand({
     });
     await build(silgi);
     if (args.commandType !== "run") {
-      await runCommand(run, {
+      await runCommand(command$1, {
         rawArgs: ["--tag", "init", "--prepare", "false"]
       });
     }
   }
 });
 
-const prepare$1 = {
+const prepare = {
   __proto__: null,
-  default: prepare
+  default: command
 };
 
-export { prepare$1 as a, commonArgs as c, prepare as p, run$1 as r };
+export { command as a, commonArgs as b, cancelOnCancel as c, prepare as p, run as r };

package/dist/cli/silgi.mjs

@@ -1,7 +1,7 @@
 import { generateDTS } from 'apiful/openapi';
 import consola$1, { consola } from 'consola';
-import { join, resolve, dirname, isAbsolute, relative, basename, extname } from 'pathe';
-import { hasSilgiModule, addTemplate, normalizeTemplate, useLogger, genEnsureSafeVar, baseHeaderBannerComment, addImports, hash, toArray, writeFile, relativeWithDot, isDirectory, addCoreFile, resolveAlias as resolveAlias$1, directoryToURL, hasError, parseServices, resolveSilgiPath } from 'silgi/kit';
+import { join, resolve, dirname, relative, isAbsolute, basename, extname } from 'pathe';
+import { hasSilgiModule, addTemplate, normalizeTemplate, useLogger, genEnsureSafeVar, baseHeaderBannerComment, addImports, hash, toArray, writeFile, relativeWithDot, isDirectory, isPresents, addCoreFile, resolveAlias as resolveAlias$1, directoryToURL, hasError, parseServices, resolveSilgiPath } from 'silgi/kit';
 import { mkdirSync, existsSync, writeFileSync, promises, readFileSync } from 'node:fs';
 import { readdir, readFile } from 'node:fs/promises';
 import { genObjectFromRawEntries, genImport, genTypeImport, genObjectFromRaw, genObjectFromValues } from 'knitwork';
@@ -486,80 +486,41 @@ ${methodEntries}
   return context;
 }
 
-async function createDTSFramework(silgi) {
-  const importItems = {
-    "silgi/types": {
-      import: [
-        {
-          name: "SilgiRuntimeContext",
-          type: true,
-          key: "SilgiRuntimeContext"
-        }
-      ],
-      from: "silgi/types"
-    }
-  };
-  const customImports = [];
-  const customContent = [];
-  await silgi.callHook("prepare:createDTSFramework", {
-    importItems,
-    customImports,
-    customContent
-  });
-  const content = [
-    ...Object.entries(importItems).map(([_name, { from, import: imports }]) => {
-      const path = isAbsolute(from) ? relativeWithDot(silgi.options.build.typesDir, from) : from;
-      if (silgi.options.typescript.removeFileExtension) {
-        from = from.replace(/\.(js|ts|mjs|cjs|jsx|tsx)$/, "");
-      }
-      return `import { ${imports.map(({ type, name }) => type ? `type ${name}` : name).join(", ")} } from '${path}'`;
-    }),
-    "",
-    ...customImports,
-    "",
-    ...customContent,
-    ""
-  ];
-  return {
-    content,
-    importItems
-  };
-}
-
 async function prepareSchema(silgi) {
-  const importItems = {
-    "silgi/types": {
-      import: [
-        {
-          name: "URIsTypes",
-          type: true,
-          key: "URIsTypes"
-        },
-        {
-          name: "Namespaces",
-          type: true,
-          key: "Namespaces"
-        },
-        {
-          name: "SilgiRuntimeContext",
-          type: true,
-          key: "SilgiRuntimeContext"
-        }
-      ],
-      from: "silgi/types"
-    },
-    "silgi/scan": {
-      import: [{
-        key: "modulesURIs",
-        name: "modulesURIs",
-        type: false
-      }],
-      from: relativeWithDot(silgi.options.build.typesDir, `${silgi.options.silgi.serverDir}/scan.ts`)
-    }
-  };
+  const { genImports, genTypeImports, addImportItem, addImportItemType } = addImports({
+    imports: [
+      {
+        specifier: relativeWithDot(
+          silgi.options.build.typesDir,
+          `${silgi.options.silgi.serverDir}/scan`
+        ),
+        imports: [
+          {
+            name: "modulesURIs"
+          }
+        ]
+      }
+    ],
+    typeImports: [
+      {
+        specifier: "silgi/types",
+        imports: [
+          {
+            name: "URIsTypes"
+          },
+          {
+            name: "Namespaces"
+          },
+          {
+            name: "SilgiRuntimeContext"
+          }
+        ]
+      }
+    ]
+  });
   const data = {
-    importItems,
-    customImports: [],
+    addImportItem,
+    addImportItemType,
     options: [],
     contexts: [],
     actions: [],
@@ -577,26 +538,34 @@ async function prepareSchema(silgi) {
     routeRules: [],
     routeRulesConfig: []
   };
-  await silgi.callHook("prepare:schema.ts", data);
-  relativeWithDot(silgi.options.build.typesDir, `${silgi.options.silgi.serverDir}/core.ts`);
-  const silgiScanTS = relativeWithDot(silgi.options.build.typesDir, `${silgi.options.silgi.serverDir}/scan.ts`);
+  await silgi.callHook("before:schema.ts", data);
+  relativeWithDot(silgi.options.build.typesDir, `${silgi.options.silgi.serverDir}/core`);
+  const silgiScanTS = relativeWithDot(silgi.options.build.typesDir, `${silgi.options.silgi.serverDir}/scan`);
   let addSilgiContext = false;
   const importsContent = [
-    ...Object.entries(importItems).map(([_name, { from, import: imports }]) => {
-      const path = isAbsolute(from) ? relativeWithDot(silgi.options.build.typesDir, from) : from;
-      if (silgi.options.typescript.removeFileExtension) {
-        from = from.replace(/\.(js|ts|mjs|cjs|jsx|tsx)$/, "");
-      }
-      return `import { ${imports.map(({ type, name }) => type ? `type ${name}` : name).join(", ")} } from '${path}'`;
+    ...genImports.map(({ specifier, imports, options }) => {
+      return genImport(specifier, imports, options);
+    }),
+    ...genTypeImports.map(({ specifier, imports }) => {
+      return genTypeImport(specifier, Array.isArray(imports) ? imports : [imports]);
     }),
-    "",
-    ...data.customImports,
     ""
   ];
   const importData = [
-    "interface InferredNamespaces {",
-    ...(silgi.options.namespaces || []).map((key) => `  ${key}: string,`),
-    "}",
+    generateTypes(
+      await resolveSchema(
+        {
+          ...silgi.options.namespaces?.reduce((acc, key) => ({ ...acc, [key]: "" }), {}) || {}
+        }
+      ),
+      {
+        interfaceName: "InferredNamespaces",
+        addExport: false,
+        addDefaults: false,
+        allowExtraKeys: false,
+        indentation: 0
+      }
+    ),
     "",
     `type SchemaExtends = Namespaces<typeof import('${silgiScanTS}')['schemas']>`,
     "",
@@ -693,7 +662,7 @@ async function prepareSchema(silgi) {
     "",
     "export {}"
   ];
-  await silgi.callHook("after:prepare:schema.ts", importData);
+  await silgi.callHook("after:schema.ts", importData);
   importData.unshift(...importsContent);
   return importData;
 }
@@ -703,10 +672,8 @@ async function writeTypesAndFiles(silgi) {
   silgi.hook("prepare:types", (opts) => {
     opts.references.push({ path: "./schema.d.ts" });
     opts.references.push({ path: "./silgi-routes.d.ts" });
-    opts.references.push({ path: "./framework.d.ts" });
   });
   const schemaContent = await prepareSchema(silgi);
-  const frameworkDTS = await createDTSFramework(silgi);
   const { declarations, tsConfig } = await silgiGenerateType(silgi);
   const tsConfigPath = resolve(
     silgi.options.rootDir,
@@ -780,10 +747,6 @@ async function writeTypesAndFiles(silgi) {
     path: tsConfigPath,
     contents: JSON.stringify(tsConfig, null, 2)
   });
-  buildFiles.push({
-    path: join(typesDir, "framework.d.ts"),
-    contents: frameworkDTS.content.join("\n")
-  });
   for await (const file of buildFiles) {
     if (!silgi.errors.length) {
       await writeFile(
@@ -835,9 +798,9 @@ export const routeRules = ${genObjectFromRawEntries(
 async function build(silgi) {
   await prepare();
   await generateApiFul(silgi);
-  await writeTypesAndFiles(silgi);
   await writeCoreFile(silgi);
   await prepareBuild(silgi);
+  await writeTypesAndFiles(silgi);
   await generateApp(silgi);
 }
 
@@ -950,41 +913,39 @@ async function prepareEnv(silgiConfig) {
 
 async function emptyFramework(silgi) {
   if (silgi.options.preset === "npm-package" || !silgi.options.preset) {
-    silgi.hook("after:prepare:schema.ts", (data) => {
+    silgi.hook("after:schema.ts", (data) => {
       data.unshift("type FrameworkContextExtends = {}");
     });
   }
 }
 
 async function h3Framework(silgi, skip = false) {
-  if (silgi.options.preset !== "h3" && skip === false)
+  if (!isPresents(["h3"]) && skip === false)
     return;
-  if (silgi.options.preset === "h3") {
-    silgi.hook("after:prepare:schema.ts", (data) => {
+  if (isPresents(["h3"])) {
+    silgi.hook("after:schema.ts", (data) => {
       data.unshift("type FrameworkContextExtends = NitroApp");
     });
   }
-  silgi.hook("prepare:schema.ts", (data) => {
-    data.importItems.nitropack = {
-      import: [
-        {
-          name: "NitroApp",
-          type: true,
-          key: "NitroApp"
-        }
-      ],
-      from: "nitropack/types"
-    };
-    data.importItems.h3 = {
-      import: [
-        {
-          name: "H3Event",
-          type: true,
-          key: "H3Event"
-        }
-      ],
-      from: "h3"
-    };
+  silgi.hook("before:schema.ts", (data) => {
+    data.addImportItemType([
+      {
+        imports: [
+          {
+            name: "H3Event"
+          }
+        ],
+        specifier: "h3"
+      },
+      {
+        imports: [
+          {
+            name: "NitroApp"
+          }
+        ],
+        specifier: "nitropack/types"
+      }
+    ]);
     data.events.push({
       key: "H3Event",
       value: "H3Event",
@@ -992,24 +953,22 @@ async function h3Framework(silgi, skip = false) {
       isSilgiContext: false
     });
   });
-  silgi.hook("prepare:createDTSFramework", (data) => {
-    data.importItems["silgi/types"] = {
-      import: [
-        {
-          name: "SilgiRuntimeContext",
-          type: true,
-          key: "SilgiRuntimeContext"
-        }
-      ],
-      from: "silgi/types"
-    };
-    data.customContent?.push(
-      "",
-      'declare module "h3" {',
-      "  interface H3EventContext extends SilgiRuntimeContext {}",
-      "}",
-      ""
-    );
+  silgi.hook("prepare:types", (opts) => {
+    addTemplate({
+      filename: "types/h3.d.ts",
+      where: ".silgi",
+      getContents: () => {
+        return [
+          "import type { SilgiRuntimeContext } from 'silgi/types'",
+          "",
+          'declare module "h3" {',
+          "  interface H3EventContext extends SilgiRuntimeContext {}",
+          "}",
+          ""
+        ].join("\n");
+      }
+    });
+    opts.references.push({ path: "./h3.d.ts" });
   });
   addCoreFile({
     before: ({ silgiConfigs }) => {
@@ -1047,45 +1006,41 @@ async function h3Framework(silgi, skip = false) {
 }
 
 async function nitroFramework(silgi, skip = false) {
-  if (silgi.options.preset !== "nitro" && skip === false)
+  if (!isPresents(["nitro"]) && skip === false)
     return;
-  silgi.hook("prepare:schema.ts", (data) => {
-    data.importItems.nitropack = {
-      import: [
+  silgi.hook("before:schema.ts", (data) => {
+    data.addImportItemType({
+      imports: [
         {
-          name: "NitroApp",
-          type: true,
-          key: "NitroApp"
+          name: "NitroApp"
         }
       ],
-      from: "nitropack/types"
-    };
+      specifier: "nitropack/types"
+    });
   });
-  silgi.hook("after:prepare:schema.ts", (data) => {
+  silgi.hook("after:schema.ts", (data) => {
     data.unshift("type FrameworkContextExtends = NitroApp");
   });
   silgi.options.plugins.push({
     packageImport: "silgi/runtime/internal/nitro",
     path: join(runtimeDir, "internal/nitro")
   });
-  silgi.hook("prepare:createDTSFramework", (data) => {
-    data.importItems["nitropack/types"] = {
-      import: [
-        {
-          name: "NitroRuntimeConfig",
-          type: true,
-          key: "NitroRuntimeConfig"
-        }
-      ],
-      from: "nitropack/types"
-    };
-    data.customContent?.push(
-      "",
-      'declare module "silgi/types" {',
-      "  interface SilgiRuntimeConfig extends NitroRuntimeConfig {}",
-      "}",
-      ""
-    );
+  silgi.hook("prepare:types", (opts) => {
+    addTemplate({
+      filename: "types/nitro.d.ts",
+      where: ".silgi",
+      getContents: () => {
+        return [
+          "import type { NitroRuntimeConfig } from 'nitropack/types'",
+          "",
+          'declare module "silgi/types" {',
+          "  interface SilgiRuntimeConfig extends NitroRuntimeConfig {}",
+          "}",
+          ""
+        ].join("\n");
+      }
+    });
+    opts.references.push({ path: "./nitro.d.ts" });
   });
   if (silgi.options.imports !== false) {
     silgi.options.imports.presets ??= [];
@@ -1107,7 +1062,7 @@ const frameworkSetup = [
 ];
 
 async function registerModuleExportScan(silgi) {
-  silgi.hook("prepare:schema.ts", async (options) => {
+  silgi.hook("before:schema.ts", async (options) => {
     for (const module of silgi.scanModules) {
       const moduleReExports = [];
       if (!module.entryPath) {
@@ -1124,106 +1079,147 @@ async function registerModuleExportScan(silgi) {
       const hasTypeExport = (name) => moduleReExports.find((exp) => exp.names?.includes(name));
       const configKey = module.meta.configKey;
       const moduleName = module.meta.name || module.meta._packageName;
-      options.importItems[configKey] = {
-        import: [],
-        from: module.meta._packageName ? moduleName : relativeWithDot(silgi.options.build.typesDir, module.entryPath)
-      };
+      const specifier = module.meta._packageName ? moduleName : relativeWithDot(silgi.options.build.typesDir, module.entryPath);
       if (hasTypeExport("ModuleOptions")) {
-        const importName = `_${hash(`${configKey}ModuleOptions`)}`;
-        options.importItems[configKey].import.push({
-          name: `ModuleOptions as ${importName}`,
-          type: true,
-          key: importName
+        const importName = hash(`${configKey}ModuleOptions`);
+        options.addImportItemType({
+          imports: [
+            {
+              as: importName,
+              name: "ModuleOptions"
+            }
+          ],
+          specifier
         });
         options.options.push({ key: configKey, value: importName });
       }
       if (hasTypeExport("ModuleRuntimeOptions")) {
-        const importName = `_${hash(`${configKey}ModuleRuntimeOptions`)}`;
-        options.importItems[configKey].import.push({
-          name: `ModuleRuntimeOptions as ${importName}`,
-          type: true,
-          key: importName
+        const importName = hash(`${configKey}ModuleRuntimeOptions`);
+        options.addImportItemType({
+          imports: [
+            {
+              as: importName,
+              name: "ModuleRuntimeOptions"
+            }
+          ],
+          specifier
         });
         options.runtimeOptions.push({ key: configKey, value: importName });
       }
       if (hasTypeExport("ModuleRuntimeShareds")) {
-        const importName = `_${hash(`${configKey}ModuleRuntimeShareds`)}`;
-        options.importItems[configKey].import.push({
-          name: `ModuleRuntimeShareds as ${importName}`,
-          type: true,
-          key: importName
+        const importName = hash(`${configKey}ModuleRuntimeShareds`);
+        options.addImportItemType({
+          imports: [
+            {
+              as: importName,
+              name: "ModuleRuntimeShareds"
+            }
+          ],
+          specifier
         });
         options.shareds.push({ key: configKey, value: importName });
       }
       if (hasTypeExport("ModuleEvents")) {
-        const importName = `_${hash(`${configKey}ModuleEvents`)}`;
-        options.importItems[configKey].import.push({
-          name: `ModuleEvents as ${importName}`,
-          type: true,
-          key: importName
+        const importName = hash(`${configKey}ModuleEvents`);
+        options.addImportItemType({
+          imports: [
+            {
+              as: importName,
+              name: "ModuleEvents"
+            }
+          ],
+          specifier
         });
         options.events.push({ key: configKey, value: importName });
       }
       if (hasTypeExport("ModuleRuntimeContexts")) {
-        const importName = `_${hash(`${configKey}ModuleRuntimeContexts`)}`;
-        options.importItems[configKey].import.push({
-          name: `ModuleRuntimeContexts as ${importName}`,
-          type: true,
-          key: importName
+        const importName = hash(`${configKey}ModuleRuntimeContexts`);
+        options.addImportItemType({
+          imports: [
+            {
+              as: importName,
+              name: "ModuleRuntimeContexts"
+            }
+          ],
+          specifier
         });
         options.contexts.push({ key: configKey, value: importName });
       }
       if (hasTypeExport("ModuleHooks")) {
-        const importName = `_${hash(`${configKey}ModuleHooks`)}`;
-        options.importItems[configKey].import.push({
-          name: `ModuleHooks as ${importName}`,
-          type: true,
-          key: importName
+        const importName = hash(`${configKey}ModuleHooks`);
+        options.addImportItemType({
+          imports: [
+            {
+              as: importName,
+              name: "ModuleHooks"
+            }
+          ],
+          specifier
         });
         options.hooks.push({ key: configKey, value: importName });
       }
       if (hasTypeExport("ModuleRuntimeHooks")) {
-        const importName = `_${hash(`${configKey}RuntimeHooks`)}`;
-        options.importItems[configKey].import.push({
-          name: `ModuleRuntimeHooks as ${importName}`,
-          type: true,
-          key: importName
+        const importName = hash(`${configKey}RuntimeHooks`);
+        options.addImportItemType({
+          imports: [
+            {
+              as: importName,
+              name: "ModuleRuntimeHooks"
+            }
+          ],
+          specifier
         });
         options.runtimeHooks.push({ key: configKey, value: importName });
       }
       if (hasTypeExport("ModuleRuntimeActions")) {
-        const importName = `_${hash(`${configKey}ModuleRuntimeActions`)}`;
-        options.importItems[configKey].import.push({
-          name: `ModuleRuntimeActions as ${importName}`,
-          type: true,
-          key: importName
+        const importName = hash(`${configKey}ModuleRuntimeActions`);
+        options.addImportItemType({
+          imports: [
+            {
+              as: importName,
+              name: "ModuleRuntimeActions"
+            }
+          ],
+          specifier
         });
         options.actions.push({ key: configKey, value: importName });
       }
       if (hasTypeExport("ModuleRuntimeMethods")) {
-        const importName = `_${hash(`${configKey}ModuleRuntimeMethods`)}`;
-        options.importItems[configKey].import.push({
-          name: `ModuleRuntimeMethods as ${importName}`,
-          type: true,
-          key: importName
+        const importName = hash(`${configKey}ModuleRuntimeMethods`);
+        options.addImportItemType({
+          imports: [
+            {
+              as: importName,
+              name: "ModuleRuntimeMethods"
+            }
+          ],
+          specifier
         });
         options.methods.push({ key: configKey, value: importName });
       }
       if (hasTypeExport("ModuleRuntimeRouteRules")) {
-        const importName = `_${hash(`${configKey}ModuleRuntimeRouteRules`)}`;
-        options.importItems[configKey].import.push({
-          name: `ModuleRuntimeRouteRules as ${importName}`,
-          type: true,
-          key: importName
+        const importName = hash(`${configKey}ModuleRuntimeRouteRules`);
+        options.addImportItemType({
+          imports: [
+            {
+              as: importName,
+              name: "ModuleRuntimeRouteRules"
+            }
+          ],
+          specifier
         });
         options.routeRules.push({ key: configKey, value: importName });
       }
       if (hasTypeExport("ModuleRuntimeRouteRulesConfig")) {
-        const importName = `_${hash(`${configKey}ModuleRuntimeRouteRulesConfig`)}`;
-        options.importItems[configKey].import.push({
-          name: `ModuleRuntimeRouteRulesConfig as ${importName}`,
-          type: true,
-          key: importName
+        const importName = hash(`${configKey}ModuleRuntimeRouteRulesConfig`);
+        options.addImportItemType({
+          imports: [
+            {
+              as: importName,
+              name: "ModuleRuntimeRouteRulesConfig"
+            }
+          ],
+          specifier
         });
         options.routeRulesConfig.push({ key: configKey, value: importName });
       }
@@ -1793,7 +1789,7 @@ async function scanExportFile(silgi) {
           return { exportName, path, _name, type: "context" };
         }));
       }
-      silgi.hook("prepare:scan.ts", (options) => {
+      silgi.hook("before:scan.ts", (options) => {
         for (const { exportName, path, _name, type } of scanTS) {
           if (!path.includes("vfs")) {
             silgi.options.devServer.watch.push(path);
@@ -1818,7 +1814,7 @@ async function scanExportFile(silgi) {
           });
         }
       });
-      silgi.hook("prepare:schema.ts", (options) => {
+      silgi.hook("before:schema.ts", (options) => {
         for (const { exportName, path, _name, type } of schemaTS) {
           if (!path.includes("vfs")) {
             silgi.options.devServer.watch.push(path);
@@ -1835,13 +1831,14 @@ async function scanExportFile(silgi) {
               value: _name
             });
           }
-          options.importItems[path] ??= {
-            import: [],
-            from: relativeWithDot(silgi.options.build.typesDir, path)
-          };
-          options.importItems[path].import.push({
-            name: `${exportName} as ${_name}`,
-            key: _name
+          options.addImportItem({
+            imports: [
+              {
+                name: _name,
+                as: exportName
+              }
+            ],
+            specifier: relativeWithDot(silgi.options.build.typesDir, path)
           });
         }
       });
@@ -1952,7 +1949,7 @@ ${injectedResult.code}`;
   }
 }
 
-async function prepareServerFiles(silgi) {
+async function prepareScanFile(silgi) {
   const { genImports, genTypeImports, addImportItem, addImportItemType } = addImports({
     imports: [
       {
@@ -1992,11 +1989,7 @@ async function prepareServerFiles(silgi) {
   const scanned = {
     uris: {},
     services: [],
-    shareds: [
-      `createShared({
-        modulesURIs,
-      })`
-    ],
+    shareds: [],
     schemas: [],
     modulesURIs: {},
     addImportItem,
@@ -2006,9 +1999,14 @@ async function prepareServerFiles(silgi) {
     defu(scanned.uris, silgi.uris);
   }
   if (silgi.modulesURIs) {
+    scanned.shareds.push(
+      `createShared({
+        modulesURIs,
+      })`
+    );
     defu(scanned.modulesURIs, silgi.modulesURIs);
   }
-  await silgi.callHook("prepare:scan.ts", scanned);
+  await silgi.callHook("before:scan.ts", scanned);
   if (scanned.services.length > 0) {
     addImportItem({
       specifier: "silgi",
@@ -2066,14 +2064,14 @@ async function prepareServerFiles(silgi) {
     scanned.shareds.length > 0 ? "])" : "}",
     ""
   ];
-  await silgi.callHook("after:prepare:scan.ts", importData);
+  await silgi.callHook("after:scan.ts", importData);
   importData.unshift(...importsContent);
   importData.unshift(...baseHeaderBannerComment);
   return importData;
 }
 
 async function writeScanFiles(silgi) {
-  const data = await prepareServerFiles(silgi);
+  const data = await prepareScanFile(silgi);
   if (!silgi.errors.length) {
     await writeFile(
       resolve(silgi.options.silgi.serverDir, "scan.ts"),
@@ -2083,7 +2081,7 @@ async function writeScanFiles(silgi) {
   await readScanFile(silgi);
   buildUriMap(silgi);
   parseServices(silgi);
-  silgi.hook("prepare:scan.ts", (file) => {
+  silgi.hook("before:scan.ts", (file) => {
     file.uris = {
       ...file.uris,
       ...silgi.uris

package/dist/types/index.d.mts

@@ -34,23 +34,6 @@ interface SilgiCompatibilityIssues extends Array<SilgiCompatibilityIssue> {
     toString: () => string;
 }
 
-/**
- * @deprecated
- */
-interface ImportItem {
-    importItems: {
-        [key: string]: {
-            import: {
-                type?: boolean;
-                name: string;
-                key: string;
-            }[];
-            from: string;
-        };
-    };
-    customImports: string[];
-    customContent?: string[];
-}
 interface SilgiCLI {
     _ignore?: Ignore;
     errors: {
@@ -185,7 +168,6 @@ interface SilgiCLIHooks extends SilgiHooks {
      */
     'close': (silgi: SilgiCLI) => HookResult;
     'reload:scan': (path: string, stats?: Stats) => HookResult;
-    'prepare:createDTSFramework': (options: ImportItem) => HookResult;
     /**
      * Allows extending compatibility checks.
      * @param compatibility Compatibility object
@@ -218,7 +200,7 @@ interface SilgiCLIHooks extends SilgiHooks {
         }) => void;
     }) => HookResult;
     'after:core.ts': (content: string[]) => HookResult;
-    'prepare:scan.ts': (data: {
+    'before:scan.ts': (data: {
         uris: Record<string, string>;
         services: string[];
         shareds: string[];
@@ -227,8 +209,10 @@ interface SilgiCLIHooks extends SilgiHooks {
         addImportItem: (data: GenImport | GenImport[]) => void;
         addImportItemType: (data: GenImport | GenImport[]) => void;
     }) => HookResult;
-    'after:prepare:scan.ts': (content: string[]) => HookResult;
-    'prepare:schema.ts': (options: {
+    'after:scan.ts': (content: string[]) => HookResult;
+    'before:schema.ts': (options: {
+        addImportItem: (data: GenImport | GenImport[]) => void;
+        addImportItemType: (data: GenImport | GenImport[]) => void;
         options: {
             key: string;
             value: string;
@@ -279,9 +263,8 @@ interface SilgiCLIHooks extends SilgiHooks {
             key: string;
             value: string;
         }[];
-    } & ImportItem) => HookResult;
-    'after:prepare:schema.ts': (content: string[]) => HookResult;
-    'prepare:framework.d.ts': (options: {} & ImportItem) => HookResult;
+    }) => HookResult;
+    'after:schema.ts': (content: string[]) => HookResult;
     'prepare:configs.ts': (cliOptions: Record<string, any>) => HookResult;
     /**
      * Called during `SilgiCLI` generation, to allow customizing, modifying or adding new files to the build directory (either virtually or to written to `.nuxt`).
@@ -1196,4 +1179,4 @@ interface ServiceParseModule {
     (params: ServiceParse): Awaited<void> | void;
 }
 
-export type { AllPaths, AppConfig, Awaitable, BaseNamespaceType, BaseSchemaType, BaseSilgiMethodType, BuildSilgi, CaptureError, CapturedErrorContext, CommandType, Commands, CreateScope, DeepPartial, DeepRequired, DefaultHooks, DefaultNamespaces, DefaultRouteConfig, DefaultRouteRules, DotenvOptions, EnvOptions, EventHandlerResponse, ExtendContext, ExtendShared, ExtractInputFromURI, ExtractOutputFromURI, ExtractPathParams, ExtractPathParamsFromURI, ExtractQueryParamsFromURI, ExtractSourceFromURI, FrameworkContext, GenImport, GenerateAppOptions, GraphQLJSON, HookResult, HttpMethod, ImportItem, LoadConfigOptions, MergedSilgiSchema, MethodHandlerType, ModuleDefinition, ModuleHookContext, ModuleMeta, ModuleOptionsCustom, ModuleSetupInstallResult, ModuleSetupReturn, Namespaces, NitroBuildInfo, RequiredServiceType, ResolvedMethodHandlerType, ResolvedModuleMeta, ResolvedModuleOptions, ResolvedServiceType, ResolvedSilgiTemplate, RouteRules, RouterParams, ScanFile, ServiceParse, ServiceParseModule, ServiceType, Silgi, SilgiAppPlugin, SilgiCLI, SilgiCLIConfig, SilgiCLIDynamicConfig, SilgiCLIHooks, SilgiCLIOptions, SilgiCommands, SilgiCompatibility, SilgiCompatibilityIssue, SilgiCompatibilityIssues, SilgiConfig, SilgiEvents, SilgiFetchClient, SilgiFetchOptions, SilgiFrameworkInfo, SilgiFunction, SilgiHooks, SilgiModule, SilgiModuleInput, SilgiModuleOptions, SilgiNamespaces, SilgiOperation, SilgiOptions, SilgiPreset, SilgiPresetMeta, SilgiRouteRules, SilgiRouterTypes, SilgiRuntimeActions, SilgiRuntimeConfig, SilgiRuntimeContext, SilgiRuntimeHooks, SilgiRuntimeMethods, SilgiRuntimeOptions, SilgiRuntimeRouteRules, SilgiRuntimeRouteRulesConfig, SilgiRuntimeShareds, SilgiRuntimeSharedsExtend, SilgiSchema, SilgiServiceInterface, SilgiStorageBase, SilgiTemplate, SilgiURIs, StorageConfig, StorageKeyGenerator, StorageKeyParams, StorageMounts, TSReference, TrimAfterFourSlashes, URIsTypes };
+export type { AllPaths, AppConfig, Awaitable, BaseNamespaceType, BaseSchemaType, BaseSilgiMethodType, BuildSilgi, CaptureError, CapturedErrorContext, CommandType, Commands, CreateScope, DeepPartial, DeepRequired, DefaultHooks, DefaultNamespaces, DefaultRouteConfig, DefaultRouteRules, DotenvOptions, EnvOptions, EventHandlerResponse, ExtendContext, ExtendShared, ExtractInputFromURI, ExtractOutputFromURI, ExtractPathParams, ExtractPathParamsFromURI, ExtractQueryParamsFromURI, ExtractSourceFromURI, FrameworkContext, GenImport, GenerateAppOptions, GraphQLJSON, HookResult, HttpMethod, LoadConfigOptions, MergedSilgiSchema, MethodHandlerType, ModuleDefinition, ModuleHookContext, ModuleMeta, ModuleOptionsCustom, ModuleSetupInstallResult, ModuleSetupReturn, Namespaces, NitroBuildInfo, RequiredServiceType, ResolvedMethodHandlerType, ResolvedModuleMeta, ResolvedModuleOptions, ResolvedServiceType, ResolvedSilgiTemplate, RouteRules, RouterParams, ScanFile, ServiceParse, ServiceParseModule, ServiceType, Silgi, SilgiAppPlugin, SilgiCLI, SilgiCLIConfig, SilgiCLIDynamicConfig, SilgiCLIHooks, SilgiCLIOptions, SilgiCommands, SilgiCompatibility, SilgiCompatibilityIssue, SilgiCompatibilityIssues, SilgiConfig, SilgiEvents, SilgiFetchClient, SilgiFetchOptions, SilgiFrameworkInfo, SilgiFunction, SilgiHooks, SilgiModule, SilgiModuleInput, SilgiModuleOptions, SilgiNamespaces, SilgiOperation, SilgiOptions, SilgiPreset, SilgiPresetMeta, SilgiRouteRules, SilgiRouterTypes, SilgiRuntimeActions, SilgiRuntimeConfig, SilgiRuntimeContext, SilgiRuntimeHooks, SilgiRuntimeMethods, SilgiRuntimeOptions, SilgiRuntimeRouteRules, SilgiRuntimeRouteRulesConfig, SilgiRuntimeShareds, SilgiRuntimeSharedsExtend, SilgiSchema, SilgiServiceInterface, SilgiStorageBase, SilgiTemplate, SilgiURIs, StorageConfig, StorageKeyGenerator, StorageKeyParams, StorageMounts, TSReference, TrimAfterFourSlashes, URIsTypes };

package/package.json

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