@rexeus/typeweaver-gen 0.2.0 → 0.3.0

package/README.md

@@ -121,18 +121,18 @@ output.
 - Copy them:
 
   ```ts
-  import path from "path";
-  import { fileURLToPath } from "url";
+  import path from "node:path";
+  import { fileURLToPath } from "node:url";
   import { BasePlugin, type GeneratorContext } from "@rexeus/typeweaver-gen";
 
-  // Needed to resolve __dirname in ES modules
-  const __dirname = path.dirname(fileURLToPath(import.meta.url));
+  // Resolve the directory of the current module
+  const moduleDir = path.dirname(fileURLToPath(import.meta.url));
 
   export default class MyPlugin extends BasePlugin {
     name = "my-plugin";
 
     generate(context: GeneratorContext) {
-      const libSourceDir = path.join(__dirname, "lib");
+      const libSourceDir = path.join(moduleDir, "lib");
       this.copyLibFiles(context, libSourceDir, this.name); // -> <output>/lib/my-plugin
     }
   }

package/dist/index.cjs

@@ -0,0 +1,278 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  BasePlugin: () => BasePlugin,
+  BaseTemplatePlugin: () => BaseTemplatePlugin,
+  Path: () => Path,
+  PluginContextBuilder: () => PluginContextBuilder,
+  PluginDependencyError: () => PluginDependencyError,
+  PluginLoadError: () => PluginLoadError,
+  PluginRegistry: () => PluginRegistry
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/plugins/types.ts
+var PluginLoadError = class extends Error {
+  constructor(pluginName, message) {
+    super(`Failed to load plugin '${pluginName}': ${message}`);
+    this.pluginName = pluginName;
+    this.name = "PluginLoadError";
+  }
+};
+var PluginDependencyError = class extends Error {
+  constructor(pluginName, missingDependency) {
+    super(
+      `Plugin '${pluginName}' depends on '${missingDependency}' which is not loaded`
+    );
+    this.pluginName = pluginName;
+    this.missingDependency = missingDependency;
+    this.name = "PluginDependencyError";
+  }
+};
+
+// src/plugins/BasePlugin.ts
+var import_node_fs = __toESM(require("node:fs"), 1);
+var import_node_path = __toESM(require("node:path"), 1);
+var BasePlugin = class {
+  description;
+  author;
+  depends;
+  config;
+  constructor(config = {}) {
+    this.config = config;
+  }
+  /**
+   * Default implementation - override in subclasses if needed
+   */
+  async initialize(context) {
+  }
+  /**
+   * Default implementation - override in subclasses if needed
+   */
+  collectResources(resources) {
+    return resources;
+  }
+  /**
+   * Default implementation - override in subclasses if needed
+   */
+  async finalize(context) {
+  }
+  /**
+   * Copy lib files from plugin package to generated lib folder
+   */
+  copyLibFiles(context, libSourceDir, libNamespace) {
+    const libDir = import_node_path.default.join(context.outputDir, "lib", libNamespace);
+    import_node_fs.default.mkdirSync(libDir, { recursive: true });
+    if (import_node_fs.default.existsSync(libSourceDir)) {
+      const files = import_node_fs.default.readdirSync(libSourceDir);
+      for (const file of files) {
+        const sourcePath = import_node_path.default.join(libSourceDir, file);
+        const targetPath = import_node_path.default.join(libDir, file);
+        if (import_node_fs.default.statSync(sourcePath).isFile()) {
+          import_node_fs.default.copyFileSync(sourcePath, targetPath);
+        }
+      }
+    }
+  }
+};
+
+// src/plugins/BaseTemplatePlugin.ts
+var import_node_fs2 = __toESM(require("node:fs"), 1);
+var import_node_path2 = __toESM(require("node:path"), 1);
+var import_ejs = require("ejs");
+var BaseTemplatePlugin = class extends BasePlugin {
+  /**
+   * Render an EJS template with the given data
+   */
+  renderTemplate(templatePath, data) {
+    const template = import_node_fs2.default.readFileSync(templatePath, "utf8");
+    return (0, import_ejs.render)(template, data);
+  }
+  /**
+   * Write a file relative to the output directory
+   */
+  writeFile(context, relativePath, content) {
+    context.writeFile(relativePath, content);
+  }
+  /**
+   * Ensure a directory exists
+   */
+  ensureDir(context, relativePath) {
+    const fullPath = import_node_path2.default.join(context.outputDir, relativePath);
+    import_node_fs2.default.mkdirSync(fullPath, { recursive: true });
+  }
+  /**
+   * Get the template path for this plugin
+   */
+  getTemplatePath(context, templateName) {
+    return import_node_path2.default.join(context.templateDir, templateName);
+  }
+};
+
+// src/plugins/PluginRegistry.ts
+var PluginRegistry = class {
+  plugins;
+  constructor() {
+    this.plugins = /* @__PURE__ */ new Map();
+  }
+  /**
+   * Register a plugin
+   */
+  register(plugin, config) {
+    if (this.plugins.has(plugin.name)) {
+      console.info(
+        `Skipping duplicate registration of required plugin: ${plugin.name}`
+      );
+      return;
+    }
+    const registration = {
+      name: plugin.name,
+      plugin,
+      config
+    };
+    this.plugins.set(plugin.name, registration);
+    console.info(`Registered plugin: ${plugin.name}`);
+  }
+  /**
+   * Get a registered plugin
+   */
+  get(name) {
+    return this.plugins.get(name);
+  }
+  /**
+   * Get all registered plugins
+   */
+  getAll() {
+    return Array.from(this.plugins.values());
+  }
+  /**
+   * Check if a plugin is registered
+   */
+  has(name) {
+    return this.plugins.has(name);
+  }
+  /**
+   * Clear all registered plugins (except required ones)
+   */
+  clear() {
+    this.plugins.clear();
+  }
+};
+
+// src/plugins/PluginContext.ts
+var import_node_fs3 = __toESM(require("node:fs"), 1);
+var import_node_path3 = __toESM(require("node:path"), 1);
+var import_ejs2 = require("ejs");
+var PluginContextBuilder = class {
+  generatedFiles = /* @__PURE__ */ new Set();
+  /**
+   * Create a basic plugin context
+   */
+  createPluginContext(params) {
+    return {
+      outputDir: params.outputDir,
+      inputDir: params.inputDir,
+      config: params.config
+    };
+  }
+  /**
+   * Create a generator context with utilities
+   */
+  createGeneratorContext(params) {
+    const pluginContext = this.createPluginContext(params);
+    return {
+      ...pluginContext,
+      resources: params.resources,
+      templateDir: params.templateDir,
+      coreDir: params.coreDir,
+      // Utility functions
+      writeFile: (relativePath, content) => {
+        const fullPath = import_node_path3.default.join(params.outputDir, relativePath);
+        const dir = import_node_path3.default.dirname(fullPath);
+        import_node_fs3.default.mkdirSync(dir, { recursive: true });
+        import_node_fs3.default.writeFileSync(fullPath, content);
+        this.generatedFiles.add(relativePath);
+        console.info(`Generated: ${relativePath}`);
+      },
+      renderTemplate: (templatePath, data) => {
+        const fullTemplatePath = import_node_path3.default.isAbsolute(templatePath) ? templatePath : import_node_path3.default.join(params.templateDir, templatePath);
+        const template = import_node_fs3.default.readFileSync(fullTemplatePath, "utf8");
+        return (0, import_ejs2.render)(template, data);
+      },
+      addGeneratedFile: (relativePath) => {
+        this.generatedFiles.add(relativePath);
+      },
+      getGeneratedFiles: () => {
+        return Array.from(this.generatedFiles);
+      }
+    };
+  }
+  /**
+   * Get all generated files
+   */
+  getGeneratedFiles() {
+    return Array.from(this.generatedFiles);
+  }
+  /**
+   * Clear generated files tracking
+   */
+  clearGeneratedFiles() {
+    this.generatedFiles.clear();
+  }
+};
+
+// src/helpers/Path.ts
+var import_node_path4 = __toESM(require("node:path"), 1);
+var Path = class {
+  static relative(from, to) {
+    const relativePath = import_node_path4.default.relative(from, to);
+    if (relativePath.includes("node_modules")) {
+      const parts = relativePath.split(import_node_path4.default.sep);
+      const index = parts.indexOf("node_modules");
+      return parts.slice(index + 1).join(import_node_path4.default.sep);
+    }
+    if (!relativePath.startsWith("./") && !relativePath.startsWith("../")) {
+      return `./${relativePath}`;
+    }
+    return relativePath;
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BasePlugin,
+  BaseTemplatePlugin,
+  Path,
+  PluginContextBuilder,
+  PluginDependencyError,
+  PluginLoadError,
+  PluginRegistry
+});

package/dist/index.d.cts

@@ -0,0 +1,276 @@
+import { IHttpOperationDefinition, IHttpResponseDefinition } from '@rexeus/typeweaver-core';
+
+type GetResourcesResult = {
+    entityResources: EntityResources;
+    sharedResponseResources: SharedResponseResource[];
+};
+type ExtendedResponseDefinition = IHttpResponseDefinition & {
+    statusCodeName: string;
+    isReference: boolean;
+};
+type EntityName = string;
+type OperationResource = {
+    sourceDir: string;
+    sourceFile: string;
+    sourceFileName: string;
+    definition: Omit<IHttpOperationDefinition, "responses"> & {
+        responses: ExtendedResponseDefinition[];
+    };
+    outputDir: string;
+    entityName: EntityName;
+    outputRequestFile: string;
+    outputRequestFileName: string;
+    outputResponseFile: string;
+    outputResponseFileName: string;
+    outputRequestValidationFile: string;
+    outputRequestValidationFileName: string;
+    outputResponseValidationFile: string;
+    outputResponseValidationFileName: string;
+    outputClientFile: string;
+    outputClientFileName: string;
+};
+type EntityResources = Record<EntityName, {
+    operations: OperationResource[];
+    responses: EntityResponseResource[];
+}>;
+type SharedResponseResource = IHttpResponseDefinition & {
+    sourceDir: string;
+    sourceFile: string;
+    sourceFileName: string;
+    outputFile: string;
+    outputFileName: string;
+    outputDir: string;
+};
+type EntityResponseResource = IHttpResponseDefinition & {
+    sourceDir: string;
+    sourceFile: string;
+    sourceFileName: string;
+    outputFile: string;
+    outputFileName: string;
+    outputDir: string;
+    entityName: EntityName;
+};
+
+/**
+ * Configuration for a typeweaver plugin
+ */
+type PluginConfig = Record<string, unknown>;
+/**
+ * Context provided to plugins during initialization and finalization
+ */
+type PluginContext = {
+    outputDir: string;
+    inputDir: string;
+    config: PluginConfig;
+};
+/**
+ * Context provided to plugins during generation
+ */
+type GeneratorContext = PluginContext & {
+    resources: GetResourcesResult;
+    templateDir: string;
+    coreDir: string;
+    writeFile: (relativePath: string, content: string) => void;
+    renderTemplate: (templatePath: string, data: unknown) => string;
+    addGeneratedFile: (relativePath: string) => void;
+    getGeneratedFiles: () => string[];
+};
+/**
+ * Plugin metadata
+ */
+type PluginMetadata = {
+    name: string;
+};
+/**
+ * typeweaver plugin interface
+ */
+type TypeweaverPlugin = PluginMetadata & {
+    /**
+     * Initialize the plugin
+     * Called before any generation happens
+     */
+    initialize?(context: PluginContext): Promise<void> | void;
+    /**
+     * Collect and transform resources
+     * Allows plugins to modify the resource collection
+     */
+    collectResources?(resources: GetResourcesResult): Promise<GetResourcesResult> | GetResourcesResult;
+    /**
+     * Main generation logic
+     * Called with all resources and utilities
+     */
+    generate?(context: GeneratorContext): Promise<void> | void;
+    /**
+     * Finalize the plugin
+     * Called after all generation is complete
+     */
+    finalize?(context: PluginContext): Promise<void> | void;
+};
+/**
+ * Plugin constructor type
+ */
+type PluginConstructor = new (config?: PluginConfig) => TypeweaverPlugin;
+/**
+ * Plugin module export
+ */
+type PluginModule = {
+    default: PluginConstructor;
+};
+/**
+ * Plugin registration entry
+ */
+type PluginRegistration = {
+    name: string;
+    plugin: TypeweaverPlugin;
+    config?: PluginConfig;
+};
+/**
+ * typeweaver configuration
+ */
+type TypeweaverConfig = {
+    input: string;
+    output: string;
+    shared?: string;
+    plugins?: (string | [string, PluginConfig])[];
+    prettier?: boolean;
+    clean?: boolean;
+};
+/**
+ * Plugin loading error
+ */
+declare class PluginLoadError extends Error {
+    pluginName: string;
+    constructor(pluginName: string, message: string);
+}
+/**
+ * Plugin dependency error
+ */
+declare class PluginDependencyError extends Error {
+    pluginName: string;
+    missingDependency: string;
+    constructor(pluginName: string, missingDependency: string);
+}
+
+/**
+ * Base class for typeweaver plugins
+ * Provides default implementations and common utilities
+ */
+declare abstract class BasePlugin implements TypeweaverPlugin {
+    abstract name: string;
+    description?: string;
+    author?: string;
+    depends?: string[];
+    protected config: PluginConfig;
+    constructor(config?: PluginConfig);
+    /**
+     * Default implementation - override in subclasses if needed
+     */
+    initialize(context: PluginContext): Promise<void>;
+    /**
+     * Default implementation - override in subclasses if needed
+     */
+    collectResources(resources: GetResourcesResult): GetResourcesResult;
+    /**
+     * Main generation logic - must be implemented by subclasses
+     */
+    abstract generate(context: GeneratorContext): Promise<void> | void;
+    /**
+     * Default implementation - override in subclasses if needed
+     */
+    finalize(context: PluginContext): Promise<void>;
+    /**
+     * Copy lib files from plugin package to generated lib folder
+     */
+    protected copyLibFiles(context: GeneratorContext, libSourceDir: string, libNamespace: string): void;
+}
+
+/**
+ * Base class for template-based generator plugins
+ * Provides utilities for working with EJS templates
+ */
+declare abstract class BaseTemplatePlugin extends BasePlugin {
+    /**
+     * Render an EJS template with the given data
+     */
+    protected renderTemplate(templatePath: string, data: unknown): string;
+    /**
+     * Write a file relative to the output directory
+     */
+    protected writeFile(context: GeneratorContext, relativePath: string, content: string): void;
+    /**
+     * Ensure a directory exists
+     */
+    protected ensureDir(context: GeneratorContext, relativePath: string): void;
+    /**
+     * Get the template path for this plugin
+     */
+    protected getTemplatePath(context: GeneratorContext, templateName: string): string;
+}
+
+/**
+ * Registry for managing typeweaver plugins
+ */
+declare class PluginRegistry {
+    private plugins;
+    constructor();
+    /**
+     * Register a plugin
+     */
+    register(plugin: TypeweaverPlugin, config?: unknown): void;
+    /**
+     * Get a registered plugin
+     */
+    get(name: string): PluginRegistration | undefined;
+    /**
+     * Get all registered plugins
+     */
+    getAll(): PluginRegistration[];
+    /**
+     * Check if a plugin is registered
+     */
+    has(name: string): boolean;
+    /**
+     * Clear all registered plugins (except required ones)
+     */
+    clear(): void;
+}
+
+/**
+ * Builder for plugin contexts
+ */
+declare class PluginContextBuilder {
+    private generatedFiles;
+    /**
+     * Create a basic plugin context
+     */
+    createPluginContext(params: {
+        outputDir: string;
+        inputDir: string;
+        config: PluginConfig;
+    }): PluginContext;
+    /**
+     * Create a generator context with utilities
+     */
+    createGeneratorContext(params: {
+        outputDir: string;
+        inputDir: string;
+        config: PluginConfig;
+        resources: GetResourcesResult;
+        templateDir: string;
+        coreDir: string;
+    }): GeneratorContext;
+    /**
+     * Get all generated files
+     */
+    getGeneratedFiles(): string[];
+    /**
+     * Clear generated files tracking
+     */
+    clearGeneratedFiles(): void;
+}
+
+declare class Path {
+    static relative(from: string, to: string): string;
+}
+
+export { BasePlugin, BaseTemplatePlugin, type EntityName, type EntityResources, type EntityResponseResource, type ExtendedResponseDefinition, type GeneratorContext, type GetResourcesResult, type OperationResource, Path, type PluginConfig, type PluginConstructor, type PluginContext, PluginContextBuilder, PluginDependencyError, PluginLoadError, type PluginMetadata, type PluginModule, type PluginRegistration, PluginRegistry, type SharedResponseResource, type TypeweaverConfig, type TypeweaverPlugin };

package/dist/index.d.ts

@@ -273,5 +273,4 @@ declare class Path {
     static relative(from: string, to: string): string;
 }
 
-export { BasePlugin, BaseTemplatePlugin, Path, PluginContextBuilder, PluginDependencyError, PluginLoadError, PluginRegistry };
-export type { EntityName, EntityResources, EntityResponseResource, ExtendedResponseDefinition, GeneratorContext, GetResourcesResult, OperationResource, PluginConfig, PluginConstructor, PluginContext, PluginMetadata, PluginModule, PluginRegistration, SharedResponseResource, TypeweaverConfig, TypeweaverPlugin };
+export { BasePlugin, BaseTemplatePlugin, type EntityName, type EntityResources, type EntityResponseResource, type ExtendedResponseDefinition, type GeneratorContext, type GetResourcesResult, type OperationResource, Path, type PluginConfig, type PluginConstructor, type PluginContext, PluginContextBuilder, PluginDependencyError, PluginLoadError, type PluginMetadata, type PluginModule, type PluginRegistration, PluginRegistry, type SharedResponseResource, type TypeweaverConfig, type TypeweaverPlugin };

package/dist/index.js

@@ -1,15 +1,12 @@
-import fs from 'fs';
-import path from 'path';
-import { render } from 'ejs';
-
-class PluginLoadError extends Error {
+// src/plugins/types.ts
+var PluginLoadError = class extends Error {
   constructor(pluginName, message) {
     super(`Failed to load plugin '${pluginName}': ${message}`);
     this.pluginName = pluginName;
     this.name = "PluginLoadError";
   }
-}
-class PluginDependencyError extends Error {
+};
+var PluginDependencyError = class extends Error {
   constructor(pluginName, missingDependency) {
     super(
       `Plugin '${pluginName}' depends on '${missingDependency}' which is not loaded`
@@ -18,9 +15,12 @@ class PluginDependencyError extends Error {
     this.missingDependency = missingDependency;
     this.name = "PluginDependencyError";
   }
-}
+};
 
-class BasePlugin {
+// src/plugins/BasePlugin.ts
+import fs from "node:fs";
+import path from "node:path";
+var BasePlugin = class {
   description;
   author;
   depends;
@@ -61,14 +61,18 @@ class BasePlugin {
       }
     }
   }
-}
+};
 
-class BaseTemplatePlugin extends BasePlugin {
+// src/plugins/BaseTemplatePlugin.ts
+import fs2 from "node:fs";
+import path2 from "node:path";
+import { render } from "ejs";
+var BaseTemplatePlugin = class extends BasePlugin {
   /**
    * Render an EJS template with the given data
    */
   renderTemplate(templatePath, data) {
-    const template = fs.readFileSync(templatePath, "utf8");
+    const template = fs2.readFileSync(templatePath, "utf8");
     return render(template, data);
   }
   /**
@@ -81,18 +85,19 @@ class BaseTemplatePlugin extends BasePlugin {
    * Ensure a directory exists
    */
   ensureDir(context, relativePath) {
-    const fullPath = path.join(context.outputDir, relativePath);
-    fs.mkdirSync(fullPath, { recursive: true });
+    const fullPath = path2.join(context.outputDir, relativePath);
+    fs2.mkdirSync(fullPath, { recursive: true });
   }
   /**
    * Get the template path for this plugin
    */
   getTemplatePath(context, templateName) {
-    return path.join(context.templateDir, templateName);
+    return path2.join(context.templateDir, templateName);
   }
-}
+};
 
-class PluginRegistry {
+// src/plugins/PluginRegistry.ts
+var PluginRegistry = class {
   plugins;
   constructor() {
     this.plugins = /* @__PURE__ */ new Map();
@@ -139,9 +144,13 @@ class PluginRegistry {
   clear() {
     this.plugins.clear();
   }
-}
+};
 
-class PluginContextBuilder {
+// src/plugins/PluginContext.ts
+import fs3 from "node:fs";
+import path3 from "node:path";
+import { render as render2 } from "ejs";
+var PluginContextBuilder = class {
   generatedFiles = /* @__PURE__ */ new Set();
   /**
    * Create a basic plugin context
@@ -165,17 +174,17 @@ class PluginContextBuilder {
       coreDir: params.coreDir,
       // Utility functions
       writeFile: (relativePath, content) => {
-        const fullPath = path.join(params.outputDir, relativePath);
-        const dir = path.dirname(fullPath);
-        fs.mkdirSync(dir, { recursive: true });
-        fs.writeFileSync(fullPath, content);
+        const fullPath = path3.join(params.outputDir, relativePath);
+        const dir = path3.dirname(fullPath);
+        fs3.mkdirSync(dir, { recursive: true });
+        fs3.writeFileSync(fullPath, content);
         this.generatedFiles.add(relativePath);
         console.info(`Generated: ${relativePath}`);
       },
       renderTemplate: (templatePath, data) => {
-        const fullTemplatePath = path.isAbsolute(templatePath) ? templatePath : path.join(params.templateDir, templatePath);
-        const template = fs.readFileSync(fullTemplatePath, "utf8");
-        return render(template, data);
+        const fullTemplatePath = path3.isAbsolute(templatePath) ? templatePath : path3.join(params.templateDir, templatePath);
+        const template = fs3.readFileSync(fullTemplatePath, "utf8");
+        return render2(template, data);
       },
       addGeneratedFile: (relativePath) => {
         this.generatedFiles.add(relativePath);
@@ -197,21 +206,30 @@ class PluginContextBuilder {
   clearGeneratedFiles() {
     this.generatedFiles.clear();
   }
-}
+};
 
-class Path {
+// src/helpers/Path.ts
+import path4 from "node:path";
+var Path = class {
   static relative(from, to) {
-    const relativePath = path.relative(from, to);
+    const relativePath = path4.relative(from, to);
     if (relativePath.includes("node_modules")) {
-      const parts = relativePath.split(path.sep);
+      const parts = relativePath.split(path4.sep);
       const index = parts.indexOf("node_modules");
-      return parts.slice(index + 1).join(path.sep);
+      return parts.slice(index + 1).join(path4.sep);
     }
     if (!relativePath.startsWith("./") && !relativePath.startsWith("../")) {
       return `./${relativePath}`;
     }
     return relativePath;
   }
-}
-
-export { BasePlugin, BaseTemplatePlugin, Path, PluginContextBuilder, PluginDependencyError, PluginLoadError, PluginRegistry };
+};
+export {
+  BasePlugin,
+  BaseTemplatePlugin,
+  Path,
+  PluginContextBuilder,
+  PluginDependencyError,
+  PluginLoadError,
+  PluginRegistry
+};

package/package.json

@@ -1,14 +1,21 @@
 {
   "name": "@rexeus/typeweaver-gen",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "Template-driven engine that turns structured API definitions into production-ready artifacts. Powered by Typeweaver 🧵✨",
   "type": "module",
-  "main": "dist/index.js",
+  "main": "dist/index.cjs",
+  "module": "dist/index.js",
   "types": "dist/index.d.ts",
   "exports": {
     ".": {
-      "import": "./dist/index.js",
-      "types": "./dist/index.d.ts"
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      }
     }
   },
   "files": [
@@ -39,10 +46,10 @@
   },
   "homepage": "https://github.com/rexeus/typeweaver#readme",
   "peerDependencies": {
-    "@rexeus/typeweaver-core": "^0.2.0"
+    "@rexeus/typeweaver-core": "^0.3.0"
   },
   "devDependencies": {
-    "@rexeus/typeweaver-core": "^0.2.0"
+    "@rexeus/typeweaver-core": "^0.3.0"
   },
   "dependencies": {
     "ejs": "^3.1.10"
@@ -50,7 +57,7 @@
   "scripts": {
     "typecheck": "tsc --noEmit",
     "format": "prettier --write .",
-    "build": "pkgroll --clean-dist && cp ../../LICENSE ../../NOTICE ./dist/",
+    "build": "tsup && cp ../../LICENSE ../../NOTICE ./dist/",
     "preversion": "npm run build"
   }
 }