@rexeus/typeweaver-gen 0.5.1 → 0.6.0

package/dist/index.cjs

@@ -1,233 +1,274 @@
-'use strict';
-
-var fs = require('node:fs');
-var path = require('node:path');
-var ejs = require('ejs');
-
-function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+//#region \0rolldown/runtime.js
+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 __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") {
+		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+			key = keys[i];
+			if (!__hasOwnProp.call(to, key) && key !== except) {
+				__defProp(to, key, {
+					get: ((k) => from[k]).bind(null, key),
+					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+				});
+			}
+		}
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
 
-var fs__default = /*#__PURE__*/_interopDefault(fs);
-var path__default = /*#__PURE__*/_interopDefault(path);
+//#endregion
+let node_fs = require("node:fs");
+node_fs = __toESM(node_fs);
+let node_path = require("node:path");
+node_path = __toESM(node_path);
+let ejs = require("ejs");
 
-// src/plugins/types.ts
+//#region src/plugins/types.ts
+/**
+* Plugin loading error
+*/
 var PluginLoadError = class extends Error {
-  constructor(pluginName, message) {
-    super(`Failed to load plugin '${pluginName}': ${message}`);
-    this.pluginName = pluginName;
-    this.name = "PluginLoadError";
-  }
+	constructor(pluginName, message) {
+		super(`Failed to load plugin '${pluginName}': ${message}`);
+		this.pluginName = pluginName;
+		this.name = "PluginLoadError";
+	}
 };
+/**
+* Plugin dependency error
+*/
 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";
-  }
+	constructor(pluginName, missingDependency) {
+		super(`Plugin '${pluginName}' depends on '${missingDependency}' which is not loaded`);
+		this.pluginName = pluginName;
+		this.missingDependency = missingDependency;
+		this.name = "PluginDependencyError";
+	}
 };
+
+//#endregion
+//#region src/plugins/BasePlugin.ts
+/**
+* Base class for typeweaver plugins
+* Provides default implementations and common utilities
+*/
 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 = path__default.default.join(context.outputDir, "lib", libNamespace);
-    fs__default.default.mkdirSync(libDir, { recursive: true });
-    if (fs__default.default.existsSync(libSourceDir)) {
-      const files = fs__default.default.readdirSync(libSourceDir);
-      for (const file of files) {
-        const sourcePath = path__default.default.join(libSourceDir, file);
-        const targetPath = path__default.default.join(libDir, file);
-        if (fs__default.default.statSync(sourcePath).isFile()) {
-          fs__default.default.copyFileSync(sourcePath, targetPath);
-        }
-      }
-      const libIndexPath = path__default.default.join("lib", libNamespace, "index.ts");
-      if (fs__default.default.existsSync(path__default.default.join(libDir, "index.ts"))) {
-        context.addGeneratedFile(libIndexPath);
-      }
-    }
-  }
+	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 = node_path.default.join(context.outputDir, "lib", libNamespace);
+		node_fs.default.mkdirSync(libDir, { recursive: true });
+		if (node_fs.default.existsSync(libSourceDir)) {
+			const files = node_fs.default.readdirSync(libSourceDir);
+			for (const file of files) {
+				const sourcePath = node_path.default.join(libSourceDir, file);
+				const targetPath = node_path.default.join(libDir, file);
+				if (node_fs.default.statSync(sourcePath).isFile()) node_fs.default.copyFileSync(sourcePath, targetPath);
+			}
+			const libIndexPath = node_path.default.join("lib", libNamespace, "index.ts");
+			if (node_fs.default.existsSync(node_path.default.join(libDir, "index.ts"))) context.addGeneratedFile(libIndexPath);
+		}
+	}
 };
+
+//#endregion
+//#region src/plugins/BaseTemplatePlugin.ts
+/**
+* Base class for template-based generator plugins
+* Provides utilities for working with EJS templates
+*/
 var BaseTemplatePlugin = class extends BasePlugin {
-  /**
-   * Render an EJS template with the given data
-   */
-  renderTemplate(templatePath, data) {
-    const template = fs__default.default.readFileSync(templatePath, "utf8");
-    return 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 = path__default.default.join(context.outputDir, relativePath);
-    fs__default.default.mkdirSync(fullPath, { recursive: true });
-  }
-  /**
-   * Get the template path for this plugin
-   */
-  getTemplatePath(context, templateName) {
-    return path__default.default.join(context.templateDir, templateName);
-  }
+	/**
+	* Render an EJS template with the given data
+	*/
+	renderTemplate(templatePath, data) {
+		return (0, ejs.render)(node_fs.default.readFileSync(templatePath, "utf8"), 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 = node_path.default.join(context.outputDir, relativePath);
+		node_fs.default.mkdirSync(fullPath, { recursive: true });
+	}
+	/**
+	* Get the template path for this plugin
+	*/
+	getTemplatePath(context, templateName) {
+		return node_path.default.join(context.templateDir, templateName);
+	}
 };
 
-// src/plugins/PluginRegistry.ts
+//#endregion
+//#region src/plugins/PluginRegistry.ts
+/**
+* Registry for managing typeweaver plugins
+*/
 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();
-  }
+	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();
+	}
 };
+
+//#endregion
+//#region src/plugins/PluginContext.ts
+/**
+* Builder for plugin contexts
+*/
 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 = path__default.default.join(params.outputDir, relativePath);
-        const dir = path__default.default.dirname(fullPath);
-        fs__default.default.mkdirSync(dir, { recursive: true });
-        fs__default.default.writeFileSync(fullPath, content);
-        this.generatedFiles.add(relativePath);
-        console.info(`Generated: ${relativePath}`);
-      },
-      renderTemplate: (templatePath, data) => {
-        const fullTemplatePath = path__default.default.isAbsolute(templatePath) ? templatePath : path__default.default.join(params.templateDir, templatePath);
-        const template = fs__default.default.readFileSync(fullTemplatePath, "utf8");
-        return ejs.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();
-  }
+	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) {
+		return {
+			...this.createPluginContext(params),
+			resources: params.resources,
+			templateDir: params.templateDir,
+			coreDir: params.coreDir,
+			writeFile: (relativePath, content) => {
+				const fullPath = node_path.default.join(params.outputDir, relativePath);
+				const dir = node_path.default.dirname(fullPath);
+				node_fs.default.mkdirSync(dir, { recursive: true });
+				node_fs.default.writeFileSync(fullPath, content);
+				this.generatedFiles.add(relativePath);
+				console.info(`Generated: ${relativePath}`);
+			},
+			renderTemplate: (templatePath, data) => {
+				const fullTemplatePath = node_path.default.isAbsolute(templatePath) ? templatePath : node_path.default.join(params.templateDir, templatePath);
+				return (0, ejs.render)(node_fs.default.readFileSync(fullTemplatePath, "utf8"), 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();
+	}
 };
+
+//#endregion
+//#region src/helpers/Path.ts
 var Path = class {
-  static relative(from, to) {
-    const relativePath = path__default.default.relative(from, to);
-    if (relativePath.includes("node_modules")) {
-      const parts = relativePath.split(path__default.default.sep);
-      const index = parts.indexOf("node_modules");
-      return parts.slice(index + 1).join("/");
-    }
-    const posixPath = relativePath.split(path__default.default.sep).join("/");
-    if (!posixPath.startsWith("./") && !posixPath.startsWith("../")) {
-      return `./${posixPath}`;
-    }
-    return posixPath;
-  }
+	static relative(from, to) {
+		const relativePath = node_path.default.relative(from, to);
+		if (relativePath.includes("node_modules")) {
+			const parts = relativePath.split(node_path.default.sep);
+			const index = parts.indexOf("node_modules");
+			return parts.slice(index + 1).join("/");
+		}
+		const posixPath = relativePath.split(node_path.default.sep).join("/");
+		if (!posixPath.startsWith("./") && !posixPath.startsWith("../")) return `./${posixPath}`;
+		return posixPath;
+	}
 };
 
+//#endregion
 exports.BasePlugin = BasePlugin;
 exports.BaseTemplatePlugin = BaseTemplatePlugin;
 exports.Path = Path;
 exports.PluginContextBuilder = PluginContextBuilder;
 exports.PluginDependencyError = PluginDependencyError;
 exports.PluginLoadError = PluginLoadError;
-exports.PluginRegistry = PluginRegistry;
+exports.PluginRegistry = PluginRegistry;