silgi 0.24.15 → 0.24.17

package/dist/cli/core/installPackage.mjs

@@ -0,0 +1,31 @@
+import { addTemplate } from 'silgi/kit';
+import { peerDependencies } from 'silgi/meta';
+
+async function installPackages(silgi) {
+  const packages = {
+    dependencies: {
+      "@fastify/deepmerge": peerDependencies["@fastify/deepmerge"],
+      "@silgi/ecosystem": peerDependencies["@silgi/ecosystem"],
+      ...silgi.options.installPackages?.dependencies
+    },
+    devDependencies: {
+      ...silgi.options.installPackages?.devDependencies
+    }
+  };
+  await silgi.callHook("prepare:installPackages", packages);
+  if (silgi.options.preset === "npm-package") {
+    packages.devDependencies = {
+      ...packages.devDependencies,
+      ...packages.dependencies
+    };
+    packages.dependencies = {};
+  }
+  addTemplate({
+    filename: "install.json",
+    where: ".silgi",
+    write: true,
+    getContents: () => JSON.stringify(packages, null, 2)
+  });
+}
+
+export { installPackages };

package/dist/cli/core/prepare.mjs

@@ -0,0 +1,7 @@
+import 'node:fs';
+import 'node:fs/promises';
+
+async function prepare(_silgi) {
+}
+
+export { prepare };

package/dist/cli/core/runtimeConfig.mjs

@@ -0,0 +1,14 @@
+import { initRuntimeConfig } from 'silgi/runtime';
+
+function useCLIRuntimeConfig(silgi) {
+  const safeRuntimeConfig = JSON.parse(JSON.stringify(silgi.options.runtimeConfig));
+  silgi.hook("prepare:configs.ts", (data) => {
+    data.runtimeConfig = safeRuntimeConfig;
+    silgi.options.envOptions = silgi.options.envOptions;
+  });
+  const _sharedRuntimeConfig = initRuntimeConfig(silgi.options.envOptions, silgi.options.runtimeConfig);
+  silgi.options.runtimeConfig = _sharedRuntimeConfig;
+  return _sharedRuntimeConfig;
+}
+
+export { useCLIRuntimeConfig };

package/dist/cli/core/scan.mjs

@@ -0,0 +1,39 @@
+import { globby } from 'globby';
+import { join, relative } from 'pathe';
+
+const GLOB_SCAN_PATTERN = "**/*.{js,mjs,cjs,ts,mts,cts,tsx,jsx}";
+async function scanAndSyncOptions(silgi) {
+  const scannedModules = await scanModules(silgi);
+  silgi.options.modules = silgi.options.modules || [];
+  for (const modPath of scannedModules) {
+    if (!silgi.options.modules.includes(modPath)) {
+      silgi.options.modules.push(modPath);
+    }
+  }
+}
+async function scanModules(silgi) {
+  const files = await scanFiles(silgi, "silgi/modules");
+  return files.map((f) => f.fullPath);
+}
+async function scanFiles(silgi, name) {
+  const files = await Promise.all(
+    silgi.options.scanDirs.map((dir) => scanDir(silgi, dir, name))
+  ).then((r) => r.flat());
+  return files;
+}
+async function scanDir(silgi, dir, name) {
+  const fileNames = await globby(join(name, GLOB_SCAN_PATTERN), {
+    cwd: dir,
+    dot: true,
+    ignore: silgi.options.ignore,
+    absolute: true
+  });
+  return fileNames.map((fullPath) => {
+    return {
+      fullPath,
+      path: relative(join(dir, name), fullPath)
+    };
+  }).sort((a, b) => a.path.localeCompare(b.path));
+}
+
+export { GLOB_SCAN_PATTERN, scanAndSyncOptions, scanModules };

package/dist/cli/core/silgi.mjs

@@ -0,0 +1,125 @@
+import { consola } from 'consola';
+import { createHooks, createDebugger } from 'hookable';
+import { join } from 'pathe';
+import { silgiCLICtx, autoImportTypes } from 'silgi';
+import { resolveSilgiPath } from 'silgi/kit';
+import { runtimeDir } from 'silgi/runtime/meta';
+import { createUnimport } from 'unimport';
+import { createRouteRules } from '../../core/routeRules.mjs';
+import { prepareEnv } from '../commands/env.mjs';
+import { frameworkSetup } from '../framework/index.mjs';
+import { registerModuleExportScan } from '../module/exportScan.mjs';
+import { installModules } from '../module/install.mjs';
+import { scanModules } from '../module/scan.mjs';
+import { commands } from '../scan/commands.mjs';
+import { scanExportFile } from '../scan/scanExportFile.mjs';
+import { writeScanFiles } from '../scan/writeScanFiles.mjs';
+import { createStorageCLI } from '../utils/storage.mjs';
+import { generateApp } from './app.mjs';
+import { installPackages } from './installPackage.mjs';
+import { useCLIRuntimeConfig } from './runtimeConfig.mjs';
+import { scanAndSyncOptions } from './scan.mjs';
+import { loadOptions } from '../config/loader.mjs';
+
+async function createSilgiCLI(config = {}, opts = {}) {
+  const options = await loadOptions(config, opts);
+  const hooks = createHooks();
+  const silgi = {
+    modulesURIs: {},
+    scannedURIs: /* @__PURE__ */ new Map(),
+    services: {},
+    uris: {},
+    shareds: {},
+    schemas: {},
+    unimport: void 0,
+    options,
+    hooks,
+    errors: [],
+    commands: {},
+    _requiredModules: {},
+    logger: consola.withTag("silgi"),
+    close: () => silgi.hooks.callHook("close", silgi),
+    storage: void 0,
+    scanModules: [],
+    templates: [],
+    callHook: hooks.callHook,
+    addHooks: hooks.addHooks,
+    hook: hooks.hook,
+    async updateConfig(_config) {
+    },
+    routeRules: void 0
+  };
+  await prepareEnv(options);
+  const routeRules = createRouteRules();
+  routeRules.importRules(options.routeRules ?? {});
+  silgi.routeRules = routeRules;
+  if (silgiCLICtx.tryUse()) {
+    silgiCLICtx.unset();
+    silgiCLICtx.set(silgi);
+  } else {
+    silgiCLICtx.set(silgi);
+    silgi.hook("close", () => silgiCLICtx.unset());
+  }
+  if (silgi.options.debug) {
+    createDebugger(silgi.hooks, { tag: "silgi" });
+    silgi.options.plugins.push({
+      path: join(runtimeDir, "internal/debug"),
+      packageImport: "silgi/runtime/internal/debug"
+    });
+  }
+  for (const framework of frameworkSetup) {
+    await framework(silgi);
+  }
+  await scanAndSyncOptions(silgi);
+  await scanModules(silgi);
+  await scanExportFile(silgi);
+  await installModules(silgi, true);
+  useCLIRuntimeConfig(silgi);
+  await writeScanFiles(silgi);
+  silgi.storage = await createStorageCLI(silgi);
+  silgi.hooks.hook("close", async () => {
+    await silgi.storage.dispose();
+  });
+  if (silgi.options.logLevel !== void 0) {
+    silgi.logger.level = silgi.options.logLevel;
+  }
+  silgi.hooks.addHooks(silgi.options.hooks);
+  await installModules(silgi);
+  await silgi.hooks.callHook("scanFiles:done", silgi);
+  await commands(silgi);
+  await installPackages(silgi);
+  await generateApp(silgi);
+  if (silgi.options.imports) {
+    silgi.options.imports.dirs ??= [];
+    silgi.options.imports.dirs = silgi.options.imports.dirs.map((dir) => {
+      if (typeof dir === "string") {
+        if (dir.startsWith("!")) {
+          return `!${resolveSilgiPath(dir.slice(1), options, silgi.options.rootDir)}`;
+        }
+        return resolveSilgiPath(dir, options, silgi.options.rootDir);
+      }
+      return dir;
+    });
+    silgi.options.imports.presets.push({
+      from: "silgi/types",
+      imports: autoImportTypes.map((type) => type),
+      type: true
+    });
+    silgi.options.imports.presets.push({
+      from: "silgi/types",
+      imports: autoImportTypes.map((type) => type),
+      type: true
+    });
+    silgi.options.imports.presets.push({
+      from: "silgi/runtime/internal/ofetch",
+      imports: ["createSilgiFetch", "silgi$fetch"]
+    });
+    silgi.unimport = createUnimport(silgi.options.imports);
+    await silgi.unimport.init();
+  }
+  await registerModuleExportScan(silgi);
+  await writeScanFiles(silgi);
+  return silgi;
+}
+
+export { createSilgiCLI };

package/dist/cli/core/templates.mjs

@@ -0,0 +1,31 @@
+const vueShim = {
+  filename: "delete/testtest.d.ts",
+  where: ".silgi",
+  getContents: ({ app }) => {
+    if (!app.options.typescript.shim) {
+      return "";
+    }
+    return [
+      "declare module '*.vue' {",
+      "  import { DefineComponent } from 'vue'",
+      "  const component: DefineComponent<{}, {}, any>",
+      "  export default component",
+      "}"
+    ].join("\n");
+  }
+};
+const pluginsDeclaration = {
+  filename: "delete/testtest1.d.ts",
+  where: ".silgi",
+  getContents: async () => {
+    return `
+      declare module 'nuxt' {
+        interface NuxtApp {
+          $myPlugin: any;
+        }
+      }
+    `;
+  }
+};
+
+export { pluginsDeclaration, vueShim };

package/dist/cli/framework/emptyFramework.mjs

@@ -0,0 +1,9 @@
+async function emptyFramework(silgi) {
+  if (silgi.options.preset === "npm-package" || !silgi.options.preset) {
+    silgi.hook("after:prepare:schema.ts", (data) => {
+      data.unshift("type FrameworkContextExtends = {}");
+    });
+  }
+}
+
+export { emptyFramework };

package/dist/cli/framework/h3.mjs

@@ -0,0 +1,89 @@
+import { resolveModuleExportNames } from 'mlly';
+
+async function h3Framework(silgi, skip = false) {
+  if (silgi.options.preset !== "h3" && skip === false)
+    return;
+  if (silgi.options.preset === "h3") {
+    silgi.hook("after:prepare: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"
+    };
+    data.events.push({
+      key: "H3Event",
+      value: "H3Event",
+      extends: true,
+      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:core.ts", (data) => {
+    data._silgiConfigs.push(`captureError: (error, context = {}) => {
+        const promise = silgi.hooks
+          .callHookParallel('error', error, context)
+          .catch((error_) => {
+            console.error('Error while capturing another error', error_)
+          })
+  
+        if (context.event && isEvent(context.event)) {
+          const errors = context.event.context.nitro?.errors
+          if (errors) {
+            errors.push({ error, context })
+          }
+          if (context.event.waitUntil) {
+            context.event.waitUntil(promise)
+          }
+        }
+      }`);
+  });
+  if (silgi.options.imports !== false) {
+    const h3Exports = await resolveModuleExportNames("h3", {
+      url: import.meta.url
+    });
+    silgi.options.imports.presets ??= [];
+    silgi.options.imports.presets.push({
+      from: "h3",
+      imports: h3Exports.filter((n) => !/^[A-Z]/.test(n) && n !== "use")
+    });
+  }
+}
+
+export { h3Framework };

package/dist/cli/framework/index.mjs

@@ -0,0 +1,8 @@
+import { emptyFramework } from './emptyFramework.mjs';
+import { h3Framework } from './h3.mjs';
+import { nitroFramework } from './nitro.mjs';
+import { nuxtFramework } from './nuxt.mjs';
+
+const frameworkSetup = [emptyFramework, h3Framework, nitroFramework, nuxtFramework];
+
+export { frameworkSetup };

package/dist/cli/framework/nitro.mjs

@@ -0,0 +1,106 @@
+import { join } from 'pathe';
+import { runtimeDir } from 'silgi/runtime/meta';
+import { h3Framework } from './h3.mjs';
+
+async function nitroFramework(silgi, skip = false) {
+  if (silgi.options.preset !== "nitro" && skip === false)
+    return;
+  silgi.hook("prepare:schema.ts", (data) => {
+    data.importItems.nitropack = {
+      import: [
+        {
+          name: "NitroApp",
+          type: true,
+          key: "NitroApp"
+        }
+      ],
+      from: "nitropack/types"
+    };
+  });
+  silgi.hook("after:prepare: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 {}",
+      "}",
+      ""
+    );
+  });
+  if (silgi.options.imports !== false) {
+    silgi.options.imports.presets ??= [];
+    silgi.options.imports.presets.push(...getNitroImportsPreset());
+  }
+  await h3Framework(silgi, true);
+}
+function getNitroImportsPreset() {
+  return [
+    {
+      from: "nitropack/runtime/internal/app",
+      imports: ["useNitroApp"]
+    },
+    {
+      from: "nitropack/runtime/internal/config",
+      imports: ["useRuntimeConfig", "useAppConfig"]
+    },
+    {
+      from: "nitropack/runtime/internal/plugin",
+      imports: ["defineNitroPlugin", "nitroPlugin"]
+    },
+    {
+      from: "nitropack/runtime/internal/cache",
+      imports: [
+        "defineCachedFunction",
+        "defineCachedEventHandler",
+        "cachedFunction",
+        "cachedEventHandler"
+      ]
+    },
+    {
+      from: "nitropack/runtime/internal/storage",
+      imports: ["useStorage"]
+    },
+    {
+      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 { nitroFramework };

package/dist/cli/framework/nuxt.mjs

@@ -0,0 +1,9 @@
+import { nitroFramework } from './nitro.mjs';
+
+async function nuxtFramework(silgi, skip = false) {
+  if (silgi.options.preset !== "nuxt" && skip === false)
+    return;
+  await nitroFramework(silgi, true);
+}
+
+export { nuxtFramework };

package/dist/cli/index.mjs

@@ -1,9 +1,6 @@
 #!/usr/bin/env node
 import { defineCommand, runMain } from 'citty';
-
-const version = "0.24.15";
-const packageJson = {
-	version: version};
+import packageJson from '../package.json.mjs';
 
 const main = defineCommand({
   meta: {
@@ -18,11 +15,11 @@ const main = defineCommand({
     }
   },
   subCommands: {
-    prepare: () => import('./prepare.mjs').then(function (n) { return n.a; }).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),
-    dev: () => import('./dev.mjs').then((m) => m.default)
+    prepare: () => import('./commands/prepare.mjs').then((m) => m.default),
+    init: () => import('./commands/init.mjs').then((m) => m.default),
+    run: () => import('./commands/run.mjs').then((m) => m.default),
+    install: () => import('./commands/install.mjs').then((m) => m.default),
+    dev: () => import('./commands/dev.mjs').then((m) => m.default)
   },
   run({ args }) {
     if (args.version)

package/dist/cli/module/exportScan.mjs

@@ -0,0 +1,130 @@
+import { promises } from 'node:fs';
+import { findTypeExports, findExports } from 'mlly';
+import { relativeWithDot, hash } from 'silgi/kit';
+
+async function registerModuleExportScan(silgi) {
+  silgi.hook("prepare:schema.ts", async (options) => {
+    for (const module of silgi.scanModules) {
+      const moduleReExports = [];
+      if (!module.entryPath) {
+        continue;
+      }
+      const moduleTypes = await promises.readFile(module.entryPath.replace(/\.mjs$/, "Types.d.ts"), "utf8").catch(() => "");
+      const normalisedModuleTypes = moduleTypes.replace(/export\s*\{.*?\}/gs, (match) => match.replace(/\b(type|interface)\b/g, ""));
+      for (const e of findTypeExports(normalisedModuleTypes)) {
+        moduleReExports.push(e);
+      }
+      for (const e of findExports(normalisedModuleTypes)) {
+        moduleReExports.push(e);
+      }
+      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)
+      };
+      if (hasTypeExport("ModuleOptions")) {
+        const importName = `_${hash(`${configKey}ModuleOptions`)}`;
+        options.importItems[configKey].import.push({
+          name: `ModuleOptions as ${importName}`,
+          type: true,
+          key: importName
+        });
+        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
+        });
+        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
+        });
+        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
+        });
+        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
+        });
+        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
+        });
+        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
+        });
+        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
+        });
+        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
+        });
+        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
+        });
+        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
+        });
+        options.routeRulesConfig.push({ key: configKey, value: importName });
+      }
+    }
+  });
+}
+
+export { registerModuleExportScan };