@silgi/module-builder 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Silgi
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/chunks/build.mjs

@@ -0,0 +1,351 @@
+import { promises, existsSync, writeFileSync } from 'node:fs';
+import { writeFile, mkdir } from 'node:fs/promises';
+import { join } from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import { defineCommand } from 'citty';
+import { consola } from 'consola';
+import defu from 'defu';
+import { createJiti } from 'dev-jiti';
+import { createRegExp, anyOf } from 'magic-regexp';
+import { resolvePath, findExports } from 'mlly';
+import { resolve, basename, normalize, dirname } from 'pathe';
+import { filename } from 'pathe/utils';
+import { readPackageJSON } from 'pkg-types';
+import { pkgDir } from 'silgi/runtime/meta';
+import { parse } from 'tsconfck';
+import { convertCompilerOptionsFromJson } from 'typescript';
+import { scanExports } from 'unimport';
+import { v as version, n as name } from '../shared/silgi-module-builder.NYdklG1f.mjs';
+
+const srcDir = fileURLToPath(new URL("src", import.meta.url));
+const subpaths = [
+  "runtime"
+];
+const build = defineCommand({
+  meta: {
+    name: "build",
+    description: "Build module for distribution"
+  },
+  args: {
+    cwd: {
+      type: "string",
+      description: "Current working directory"
+    },
+    rootDir: {
+      type: "positional",
+      description: "Root directory",
+      required: false
+    },
+    outDir: {
+      type: "string"
+    },
+    sourcemap: {
+      type: "boolean"
+    },
+    stub: {
+      type: "boolean"
+    },
+    check: {
+      type: "boolean"
+    }
+  },
+  async run(context) {
+    const { build } = await import('unbuild');
+    const cwd = resolve(context.args.cwd || context.args.rootDir || ".");
+    let packageData = await readPackageJSON(cwd);
+    const jiti = createJiti(cwd);
+    const outDir = context.args.outDir || "dist";
+    function check() {
+      if (packageData) {
+        const expectedExports = {
+          ".": {
+            import: {
+              types: "./dist/module.d.ts",
+              default: "./dist/module.mjs"
+            }
+          },
+          "./module": {
+            types: "./dist/module.d.ts",
+            import: "./dist/module.mjs"
+          },
+          "./runtime": {
+            silgi: "./dist/runtime/index.ts",
+            silgiTypes: "./dist/runtime/index.ts",
+            types: "./runtime.d.ts",
+            import: "./dist/runtime/index.mjs"
+          },
+          "./runtime/*": {
+            silgi: "./dist/runtime/*.ts",
+            silgiTypes: "./dist/runtime/*.ts",
+            types: "./dist/runtime/*.d.ts",
+            import: "./dist/runtime/*.mjs"
+          }
+        };
+        packageData.exports = defu(packageData.exports, expectedExports);
+        packageData = defu(packageData, {
+          main: "./dist/module.mjs",
+          types: "./dist/module.d.ts",
+          scripts: {
+            "build": "pnpm silgi-module-build build",
+            "build:stub": "pnpm silgi-module-build build --stub",
+            "test": "vitest",
+            "test:coverage": "vitest run --coverage"
+          }
+        });
+      }
+      writeFileSync(resolve(cwd, "package.json"), JSON.stringify(packageData, null, 2));
+    }
+    if (context.args.check) {
+      check();
+      return;
+    }
+    const rootPkg = await readPackageJSON(join(pkgDir, "package.json"));
+    await build(cwd, false, {
+      declaration: true,
+      sourcemap: context.args.sourcemap,
+      stub: context.args.stub,
+      outDir,
+      // eslint-disable-next-line ts/ban-ts-comment
+      // @ts-ignore
+      ignoreConditions: ["silgi", "silgiTypes"],
+      entries: [
+        "src/module",
+        {
+          input: "src/runtime/",
+          outDir: `${outDir}/runtime`,
+          builder: "mkdist",
+          format: "esm",
+          // addRelativeDeclarationExtensions: true,
+          // ext: 'js',
+          pattern: [
+            "**",
+            "!**/*.stories.{js,cts,mts,ts,jsx,tsx}",
+            // ignore storybook files
+            "!**/*.{spec,test}.{js,cts,mts,ts,jsx,tsx}"
+            // ignore tests
+          ]
+          // esbuild: {
+          //   jsxImportSource: 'vue',
+          //   jsx: 'automatic',
+          //   jsxFactory: 'h',
+          // },
+        }
+      ],
+      rollup: {
+        esbuild: {
+          target: "esnext"
+        },
+        emitCJS: false,
+        cjsBridge: false
+      },
+      externals: [
+        /dist[\\/]runtime[\\/]/,
+        "silgi",
+        "silgi/kit",
+        "silgi/runtime",
+        "silgi/module",
+        ...Object.keys(packageData.dependencies || {}),
+        ...Object.keys(packageData.peerDependencies || {}),
+        ...Object.keys(rootPkg.dependencies || {}),
+        ...Object.keys(rootPkg.peerDependencies || {})
+      ],
+      hooks: {
+        "mkdist:entry:options": async function(_ctx, entry, options) {
+          options.typescript = defu(options.typescript, {
+            compilerOptions: await loadTSCompilerOptions(entry.input)
+          });
+        },
+        "rollup:options": async function(ctx, options) {
+          const [entry] = ctx.buildEntries;
+          const mergedCompilerOptions = defu({
+            noEmit: false,
+            paths: {
+              "#app/silgi": ["./node_modules/silgi/dist/app/silgi"]
+            }
+          }, ctx.options.rollup.dts.compilerOptions, await loadTSCompilerOptions(entry.path));
+          ctx.options.rollup.dts.compilerOptions = convertCompilerOptionsFromJson(mergedCompilerOptions, entry.path).options;
+          options.plugins ||= [];
+          if (!Array.isArray(options.plugins))
+            options.plugins = [options.plugins];
+          const runtimeEntries = ctx.options.entries.filter((entry2) => entry2.builder === "mkdist");
+          const runtimeDirs = runtimeEntries.map((entry2) => basename(entry2.input));
+          const RUNTIME_RE = createRegExp(anyOf(...runtimeDirs).and(anyOf("/", "\\")));
+          options.plugins.unshift({
+            name: "silgi-module-builder:runtime-externals",
+            async resolveId(id, importer) {
+              if (!RUNTIME_RE.test(id))
+                return;
+              const resolved = await this.resolve(id, importer, { skipSelf: true });
+              if (!resolved)
+                return;
+              const normalizedId = normalize(resolved.id);
+              for (const entry2 of runtimeEntries) {
+                if (!normalizedId.includes(entry2.input))
+                  continue;
+                const distFile = await resolvePath(join(dirname(pathToFileURL(normalizedId).href.replace(entry2.input, entry2.outDir)), filename(normalizedId)));
+                if (distFile) {
+                  return {
+                    external: true,
+                    id: distFile
+                  };
+                }
+              }
+            }
+          });
+        },
+        "rollup:build": async function(ctx) {
+          const runtimeDir = resolve(ctx.options.rootDir, "src", "runtime");
+          const runtimeIndexPath = resolve(runtimeDir, "index.ts");
+          if (!existsSync(runtimeDir)) {
+            await mkdir(runtimeDir, { recursive: true });
+          }
+          if (!existsSync(runtimeIndexPath)) {
+            await writeFile(runtimeIndexPath, "export default {}");
+          }
+        },
+        "rollup:done": async function(ctx) {
+          const moduleEntryPath = resolve(ctx.options.outDir, "module.mjs");
+          const moduleFn = await jiti.import(pathToFileURL(moduleEntryPath).toString(), { default: true }).catch((err) => {
+            consola.error(err);
+            consola.error("Cannot load module. Please check dist:", moduleEntryPath);
+            return null;
+          });
+          if (!moduleFn) {
+            return;
+          }
+          const moduleMeta = await moduleFn.getMeta?.() || {};
+          const moduleRawPath = resolve(ctx.options.rootDir, "src/module.ts");
+          const _exports = await scanExports(moduleRawPath, true);
+          const cleanedExports = _exports.map(({ from, ...rest }) => rest);
+          moduleMeta.exports = cleanedExports;
+          if (ctx.pkg) {
+            if (!moduleMeta.name) {
+              moduleMeta.name = ctx.pkg.name;
+            }
+            if (!moduleMeta.version) {
+              moduleMeta.version = ctx.pkg.version;
+            }
+          }
+          moduleMeta._packageName = ctx.pkg.name;
+          if (ctx.pkg.modules) {
+            moduleMeta._modules = ctx.pkg.configmodules;
+          }
+          moduleMeta.builder = {
+            [name]: version,
+            unbuild: await readPackageJSON("unbuild").then((r) => r.version).catch(() => "unknown")
+          };
+          const metaFile = resolve(ctx.options.outDir, "module.json");
+          await promises.writeFile(metaFile, JSON.stringify(moduleMeta, null, 2), "utf8");
+          await writeTypes(ctx.options, ctx.options.stub, moduleMeta);
+        },
+        "build:prepare": async function(_ctx) {
+          for (const subpath of subpaths) {
+            await writeFile(
+              `./${subpath}.d.ts`,
+              `export * from './dist/${subpath}/index';`
+            );
+          }
+        }
+      },
+      stubOptions: {
+        jiti: {
+          alias: {
+            [`${packageData.name}/runtime/*`]: resolve(srcDir, "../runtime/*")
+          }
+        }
+      }
+    });
+  }
+});
+async function writeTypes(options, isStub, moduleMeta) {
+  const dtsFile = resolve(options.outDir, "types.d.ts");
+  if (existsSync(dtsFile)) {
+    return;
+  }
+  const moduleReExports = [];
+  if (!isStub) {
+    const moduleTypesFile = resolve(options.outDir, "module.d.mts");
+    const moduleTypes = await promises.readFile(moduleTypesFile, "utf8").catch(() => "");
+    const normalisedModuleTypes = moduleTypes.replace(/export\s*\{.*?\}/gs, (match) => match.replace(/\b(type|interface)\b/g, ""));
+    for (const e of findExports(normalisedModuleTypes)) {
+      moduleReExports.push(e);
+    }
+  }
+  const schemaShims = [];
+  const moduleImports = [];
+  const schemaImports = [];
+  const moduleExports = [];
+  const hasTypeExport = (name2) => isStub || moduleReExports.find((exp) => exp.names?.includes(name2));
+  if (!hasTypeExport("ModuleOptions")) {
+    schemaImports.push("SilgiModule");
+    moduleImports.push("default as Module");
+    moduleExports.push(`export type ModuleOptions = typeof Module extends SilgiModule<infer O> ? Partial<O> : Record<string, any>`);
+  }
+  if (hasTypeExport("ModuleOptions")) {
+    moduleImports.push("ModuleOptions");
+    schemaShims.push(`  interface SilgiModuleOptions { ${moduleMeta.configKey}: ModuleOptions }`);
+  }
+  if (hasTypeExport("ModuleRuntimeOptions")) {
+    moduleImports.push("ModuleRuntimeOptions");
+    schemaShims.push(`  interface SilgiRuntimeOptions { ${moduleMeta.configKey}: ModuleRuntimeOptions }`);
+  }
+  if (hasTypeExport("ModuleShareds")) {
+    moduleImports.push("ModuleShareds");
+    schemaShims.push("  interface SilgiShared extends ModuleShareds {}");
+  }
+  if (hasTypeExport("ModuleEvents")) {
+    moduleImports.push("ModuleEvents");
+    schemaShims.push("  interface SilgiEvent extends ModuleEvents {}");
+  }
+  if (hasTypeExport("ModuleRuntimeContexts")) {
+    moduleImports.push("ModuleRuntimeContexts");
+    schemaShims.push("  interface SilgiRuntimeContext extends ModuleRuntimeContexts {}");
+  }
+  if (hasTypeExport("ModuleHooks")) {
+    moduleImports.push("ModuleHooks");
+    schemaShims.push("  interface SilgiHooks extends ModuleHooks {}");
+  }
+  if (hasTypeExport("ModuleRuntimeHooks")) {
+    moduleImports.push("ModuleRuntimeHooks");
+    schemaShims.push("  interface SilgiRuntimeHooks extends ModuleRuntimeHooks {}");
+  }
+  if (hasTypeExport("ModuleRuntimeActions")) {
+    moduleImports.push("ModuleRuntimeActions");
+    schemaShims.push(`  interface SilgiRuntimeActions { ${moduleMeta.configKey}: ModuleRuntimeActions }`);
+  }
+  const dtsContents = `${`
+  ${schemaImports.length ? `import type { ${schemaImports.join(", ")} } from 'silgi/types'` : ""}
+
+${moduleImports.length ? `import type { ${moduleImports.join(", ")} } from './module.mjs'` : ""}
+
+${schemaShims.length ? `declare module 'silgi/types' {
+${schemaShims.join("\n")}
+}
+` : ""}
+${moduleExports.length ? `
+${moduleExports.join("\n")}` : ""}
+${isStub ? 'export * from "./module.mjs"' : ""}
+${moduleReExports[0] ? `
+export { ${moduleReExports[0].names.map((n) => (n === "default" ? "" : "type ") + n).join(", ")} } from './module.mjs'` : ""}
+`.trim().replace(/[\n\r]{3,}/g, "\n\n")}
+`;
+  await promises.writeFile(dtsFile, dtsContents, "utf8");
+  await promises.writeFile(resolve(options.rootDir, "types.d.ts"), `export * from './dist/types';
+`, "utf8");
+}
+async function loadTSCompilerOptions(path) {
+  const config = await parse(path);
+  const resolvedCompilerOptions = config?.tsconfig.compilerOptions || {};
+  for (const { tsconfig, tsconfigFile } of config.extended || []) {
+    for (const alias in tsconfig.compilerOptions?.paths || {}) {
+      resolvedCompilerOptions.paths[alias] = resolvedCompilerOptions.paths[alias].map((p) => {
+        if (!/^\.{1,2}(?:\/|$)/.test(p))
+          return p;
+        return resolve(dirname(tsconfigFile), p);
+      });
+    }
+  }
+  return resolvedCompilerOptions;
+}
+
+export { build as default, subpaths };

package/dist/cli.d.mts

@@ -0,0 +1 @@
+

package/dist/cli.d.ts

@@ -0,0 +1 @@
+

package/dist/cli.mjs

@@ -0,0 +1,25 @@
+#!/usr/bin/env node
+import { defineCommand, runMain } from 'citty';
+import { consola } from 'consola';
+import { v as version, d as description, n as name } from './shared/silgi-module-builder.NYdklG1f.mjs';
+
+const _rDefault = (r) => r && typeof r === "object" && "default" in r ? r.default : r;
+const main = defineCommand({
+  meta: {
+    name,
+    description,
+    version
+  },
+  subCommands: {
+    // prepare: () => import('./commands/prepare').then(_rDefault),
+    build: () => import('./chunks/build.mjs').then(_rDefault)
+  },
+  setup(context) {
+    const firstArg = context.rawArgs[0];
+    if (context.cmd.subCommands && !(firstArg && firstArg in context.cmd.subCommands)) {
+      consola.warn("Please specify the `build` command explicitly. In a future version of `@silgi/module-builder`, the implicit default build command will be removed.");
+      context.rawArgs.unshift("build");
+    }
+  }
+});
+runMain(main);

package/dist/index.d.mts

@@ -0,0 +1,27 @@
+import * as citty from 'citty';
+
+declare const _default: citty.CommandDef<{
+    cwd: {
+        type: "string";
+        description: string;
+    };
+    rootDir: {
+        type: "positional";
+        description: string;
+        required: false;
+    };
+    outDir: {
+        type: "string";
+    };
+    sourcemap: {
+        type: "boolean";
+    };
+    stub: {
+        type: "boolean";
+    };
+    check: {
+        type: "boolean";
+    };
+}>;
+
+export { _default as build };

package/dist/index.d.ts

@@ -0,0 +1,27 @@
+import * as citty from 'citty';
+
+declare const _default: citty.CommandDef<{
+    cwd: {
+        type: "string";
+        description: string;
+    };
+    rootDir: {
+        type: "positional";
+        description: string;
+        required: false;
+    };
+    outDir: {
+        type: "string";
+    };
+    sourcemap: {
+        type: "boolean";
+    };
+    stub: {
+        type: "boolean";
+    };
+    check: {
+        type: "boolean";
+    };
+}>;
+
+export { _default as build };

package/dist/index.mjs

@@ -0,0 +1,19 @@
+export { default as build } from './chunks/build.mjs';
+import 'node:fs';
+import 'node:fs/promises';
+import 'node:path';
+import 'node:url';
+import 'citty';
+import 'consola';
+import 'defu';
+import 'dev-jiti';
+import 'magic-regexp';
+import 'mlly';
+import 'pathe';
+import 'pathe/utils';
+import 'pkg-types';
+import 'silgi/runtime/meta';
+import 'tsconfck';
+import 'typescript';
+import 'unimport';
+import './shared/silgi-module-builder.NYdklG1f.mjs';

package/dist/shared/silgi-module-builder.NYdklG1f.mjs

@@ -0,0 +1,5 @@
+const name = "@silgi/module-builder";
+const version = "0.0.1";
+const description = "Complete solution for building Silgi modules";
+
+export { description as d, name as n, version as v };

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "@silgi/module-builder",
+  "type": "module",
+  "version": "0.0.1",
+  "private": false,
+  "description": "Complete solution for building Silgi modules",
+  "exports": {
+    ".": "./dist/index.mjs",
+    "./package.json": "./package.json"
+  },
+  "bin": {
+    "silgi-module-build": "./dist/cli.mjs"
+  },
+  "files": [
+    "dist"
+  ],
+  "peerDependencies": {
+    "silgi": "^0.7.6",
+    "typescript": "^5.7.3"
+  },
+  "dependencies": {
+    "citty": "^0.1.6",
+    "consola": "^3.4.0",
+    "defu": "^6.1.4",
+    "dev-jiti": "^2.4.2",
+    "magic-regexp": "^0.8.0",
+    "mlly": "^1.7.4",
+    "pathe": "^2.0.2",
+    "pkg-types": "^1.3.1",
+    "silgi": "^0.7.6",
+    "tsconfck": "^3.1.5",
+    "unbuild": "^3.3.1",
+    "unimport": "^4.1.1"
+  },
+  "devDependencies": {
+    "@antfu/eslint-config": "^4.2.0",
+    "@types/node": "^22.13.1",
+    "eslint": "^9.20.1",
+    "typescript": "^5.7.3"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "unbuild",
+    "dev:prepare": "unbuild --stub && pnpm -r dev:prepare",
+    "build:stub": "unbuild --stub",
+    "release": "pnpm build && pnpm publish",
+    "lint": "eslint .",
+    "lint:fix": "eslint . --fix"
+  }
+}