@tiveor/scg 0.1.6 → 0.5.0

package/dist/index.cjs

@@ -0,0 +1,991 @@
+"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, {
+  CommandHelper: () => CommandHelper,
+  FileHelper: () => FileHelper,
+  ParamHelper: () => ParamHelper,
+  Pipeline: () => Pipeline,
+  Scaffold: () => Scaffold,
+  StringHelper: () => StringHelper,
+  TEMPLATE_HANDLERS: () => TEMPLATE_HANDLERS,
+  TemplateBuilder: () => TemplateBuilder,
+  Watcher: () => Watcher
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/string_helper.ts
+var StringHelper = class _StringHelper {
+  /**
+   * Escapes all regex special characters in a string.
+   *
+   * @param string - The string to escape
+   * @returns The escaped string safe for use in `new RegExp()`
+   *
+   * @example
+   * ```typescript
+   * StringHelper.escapeRegex('$100.00 (test)');
+   * // => "\\$100\\.00 \\(test\\)"
+   * ```
+   */
+  static escapeRegex(string) {
+    return string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  }
+  /**
+   * Replaces all occurrences of a token in a string. The token is treated
+   * as a literal string (regex special characters are escaped automatically).
+   *
+   * @param line - The source string to search in. Returns `''` if not a string.
+   * @param token - The token to search for. Returns `line` unchanged if not a string.
+   * @param value - The replacement value
+   * @returns The string with all occurrences replaced
+   *
+   * @example
+   * ```typescript
+   * StringHelper.replace('Price: $10.00', '$10.00', '$20.00');
+   * // => "Price: $20.00"
+   * ```
+   */
+  static replace(line, token, value) {
+    if (typeof line !== "string") return "";
+    if (typeof token !== "string") return line;
+    return line.replace(
+      new RegExp(_StringHelper.escapeRegex(token), "g"),
+      value
+    );
+  }
+  /**
+   * Capitalizes the first character of a string.
+   *
+   * @param s - The string to capitalize. Returns `''` if not a string.
+   * @returns The string with the first character uppercased
+   *
+   * @example
+   * ```typescript
+   * StringHelper.capitalize('hello world');
+   * // => "Hello world"
+   * ```
+   */
+  static capitalize(s) {
+    if (typeof s !== "string") return "";
+    return s.charAt(0).toUpperCase() + s.slice(1);
+  }
+};
+
+// src/file_helper.ts
+var import_fs = __toESM(require("fs"), 1);
+var import_path = __toESM(require("path"), 1);
+var import_readline = __toESM(require("readline"), 1);
+var FileHelper = class _FileHelper {
+  // --- Sync methods ---
+  /**
+   * Reads a file synchronously and returns its content as a UTF-8 string.
+   *
+   * @param fileName - Path to the file to read
+   * @returns The file content as a string
+   */
+  static readFileToString(fileName) {
+    return import_fs.default.readFileSync(fileName, "utf8");
+  }
+  /**
+   * Reads a JSON file synchronously and parses it into an object.
+   *
+   * @typeParam T - The expected type of the parsed object
+   * @param fileName - Path to the JSON file
+   * @returns The parsed object
+   */
+  static convertJsonFileToObject(fileName) {
+    const rawString = _FileHelper.readFileToString(fileName);
+    return JSON.parse(rawString);
+  }
+  /**
+   * Creates a directory (and any parent directories) if it doesn't exist.
+   *
+   * @param folderName - Path to the directory to create
+   */
+  static createFolder(folderName) {
+    const resolved = import_path.default.resolve(folderName);
+    if (!import_fs.default.existsSync(resolved)) {
+      import_fs.default.mkdirSync(resolved, { recursive: true });
+    }
+  }
+  /**
+   * Removes a directory and all its contents recursively.
+   *
+   * @param folderName - Path to the directory to remove
+   */
+  static removeFolder(folderName) {
+    const resolved = import_path.default.resolve(folderName);
+    if (import_fs.default.existsSync(resolved)) {
+      import_fs.default.rmSync(resolved, { recursive: true, force: true });
+    }
+  }
+  /**
+   * Removes a file if it exists.
+   *
+   * @param filename - Path to the file to remove
+   */
+  static removeFile(filename) {
+    const resolved = import_path.default.resolve(filename);
+    if (import_fs.default.existsSync(resolved)) {
+      import_fs.default.rmSync(resolved, { force: true });
+    }
+  }
+  // --- Async methods ---
+  /**
+   * Reads a file asynchronously and returns its content as a UTF-8 string.
+   *
+   * @param fileName - Path to the file to read
+   * @returns A promise resolving to the file content
+   */
+  static async readFileAsync(fileName) {
+    return import_fs.default.promises.readFile(fileName, "utf8");
+  }
+  /**
+   * Reads a JSON file asynchronously and parses it into an object.
+   *
+   * @typeParam T - The expected type of the parsed object
+   * @param fileName - Path to the JSON file
+   * @returns A promise resolving to the parsed object
+   */
+  static async readJsonFileAsync(fileName) {
+    const raw = await import_fs.default.promises.readFile(fileName, "utf8");
+    return JSON.parse(raw);
+  }
+  /**
+   * Writes content to a file asynchronously, creating parent directories as needed.
+   *
+   * @param fileName - Path to the file to write
+   * @param content - The string content to write
+   */
+  static async writeFileAsync(fileName, content) {
+    const dir = import_path.default.dirname(fileName);
+    await import_fs.default.promises.mkdir(dir, { recursive: true });
+    await import_fs.default.promises.writeFile(fileName, content, "utf8");
+  }
+  /**
+   * Creates a directory asynchronously (with recursive parent creation).
+   *
+   * @param folderName - Path to the directory to create
+   */
+  static async createFolderAsync(folderName) {
+    const resolved = import_path.default.resolve(folderName);
+    await import_fs.default.promises.mkdir(resolved, { recursive: true });
+  }
+  /**
+   * Removes a directory and its contents recursively (async).
+   *
+   * @param folderName - Path to the directory to remove
+   */
+  static async removeFolderAsync(folderName) {
+    const resolved = import_path.default.resolve(folderName);
+    await import_fs.default.promises.rm(resolved, { recursive: true, force: true });
+  }
+  /**
+   * Removes a file asynchronously.
+   *
+   * @param filename - Path to the file to remove
+   */
+  static async removeFileAsync(filename) {
+    const resolved = import_path.default.resolve(filename);
+    await import_fs.default.promises.rm(resolved, { force: true });
+  }
+  /**
+   * Checks whether a file or directory exists asynchronously.
+   *
+   * @param filePath - Path to check
+   * @returns `true` if the path exists, `false` otherwise
+   */
+  static async existsAsync(filePath) {
+    try {
+      await import_fs.default.promises.access(filePath);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  // --- Template processing methods ---
+  /**
+   * Performs a simple token replacement on a single line.
+   *
+   * @param line - The source line
+   * @param replacement - The replacement definition (uses `token` and `value`)
+   * @returns The line with the token replaced
+   */
+  static simpleReplace(line, replacement) {
+    return StringHelper.replace(line, replacement.token, replacement.value);
+  }
+  /**
+   * Performs dynamic replacement using a sub-template and variables.
+   * Reads the sub-template line by line and applies all variable replacements.
+   *
+   * @param replacement - The replacement definition with `template` and `variables`
+   * @returns A promise resolving to the processed string
+   */
+  static async dynamicReplace(replacement) {
+    let res = "";
+    for (const v in replacement.variables) {
+      const properties = replacement.variables[v];
+      await _FileHelper.readLineByLine(
+        replacement.template,
+        (line) => {
+          let newLine = line;
+          for (const x in properties) {
+            const property = properties[x];
+            if (line.indexOf(property.token) >= 0) {
+              if (property.value) {
+                newLine = _FileHelper.simpleReplace(newLine, property);
+              }
+            }
+          }
+          res += newLine;
+        }
+      );
+    }
+    return res;
+  }
+  /**
+   * Creates a new file from a template file, applying variable replacements line by line.
+   * The special token `@date` is automatically replaced with the current UTC date.
+   *
+   * @param options - The template path, output path, and variables to apply
+   *
+   * @example
+   * ```typescript
+   * await FileHelper.createFileFromFile({
+   *   template: 'templates/component.txt',
+   *   newFile: 'output/Button.tsx',
+   *   variables: [
+   *     { token: '{{name}}', value: 'Button' },
+   *     { token: '{{style}}', value: 'primary' }
+   *   ]
+   * });
+   * ```
+   */
+  static async createFileFromFile({
+    template,
+    newFile,
+    variables
+  }) {
+    const writer = _FileHelper.writer(newFile);
+    await _FileHelper.readLineByLine(template, async (line) => {
+      let newLine = StringHelper.replace(
+        line,
+        "@date",
+        (/* @__PURE__ */ new Date()).toUTCString()
+      );
+      for (const v in variables) {
+        const replacement = variables[v];
+        if (newLine.indexOf(replacement.token) > 0) {
+          if (replacement.template) {
+            newLine = await _FileHelper.dynamicReplace(replacement);
+            break;
+          } else if (replacement.value) {
+            newLine = _FileHelper.simpleReplace(newLine, replacement);
+          }
+        }
+      }
+      await _FileHelper.writeLineByLine(writer, newLine);
+    });
+    writer.end();
+  }
+  /**
+   * Creates a string from a template file, applying variable replacements line by line.
+   * The special token `@date` is automatically replaced with the current UTC date.
+   *
+   * @param options - The template path and variables to apply
+   * @returns A promise resolving to the processed string
+   */
+  static async createStringFromFile({
+    template,
+    variables
+  }) {
+    let res = "";
+    await _FileHelper.readLineByLine(template, async (line) => {
+      let newLine = StringHelper.replace(
+        line,
+        "@date",
+        (/* @__PURE__ */ new Date()).toUTCString()
+      );
+      for (const v in variables) {
+        const replacement = variables[v];
+        if (newLine.indexOf(replacement.token) > 0) {
+          if (replacement.template) {
+            newLine = await _FileHelper.dynamicReplace(replacement);
+            break;
+          } else if (replacement.value) {
+            newLine = _FileHelper.simpleReplace(newLine, replacement);
+          }
+        }
+      }
+      res += newLine + "\n";
+    });
+    return res;
+  }
+  /**
+   * Reads a file line by line and invokes a callback for each line.
+   *
+   * @param fileName - Path to the file to read
+   * @param callback - Function called for each line
+   */
+  static async readLineByLine(fileName, callback) {
+    const fileStream = import_fs.default.createReadStream(fileName);
+    const rl = import_readline.default.createInterface({
+      input: fileStream,
+      crlfDelay: Infinity
+    });
+    for await (const line of rl) {
+      await callback(line);
+    }
+  }
+  /**
+   * Creates a writable stream for appending to a file.
+   *
+   * @param filename - Path to the file
+   * @returns A writable stream in append mode
+   */
+  static writer(filename) {
+    return import_fs.default.createWriteStream(filename, {
+      flags: "a"
+    });
+  }
+  /**
+   * Writes a single line to a writable stream with CRLF line ending.
+   *
+   * @param writer - The writable stream
+   * @param newLine - The line content to write
+   */
+  static async writeLineByLine(writer, newLine) {
+    writer.write(`${newLine}\r
+`);
+  }
+};
+
+// src/command_helper.ts
+var import_child_process = require("child_process");
+var FORBIDDEN_PATTERNS = [
+  /[;&|`$]/,
+  // shell metacharacters
+  /\$\(/,
+  // command substitution
+  />\s*\//,
+  // redirect to absolute path
+  /\.\.\//
+  // path traversal
+];
+var CommandHelper = class _CommandHelper {
+  /**
+   * Executes one or more shell commands in the given directory.
+   * Multiple commands are joined with `&&` (sequential execution).
+   *
+   * @param directory - Working directory for command execution
+   * @param command - One or more command strings to execute
+   * @returns A promise resolving to the command's stdout (or stderr if stdout is empty)
+   * @throws If the directory is empty, no commands are provided, or a command matches a forbidden pattern
+   *
+   * @example
+   * ```typescript
+   * const output = await CommandHelper.run('.', 'echo hello');
+   * // => "hello\n"
+   *
+   * const result = await CommandHelper.run('.', 'git add .', 'git status');
+   * ```
+   */
+  static run(directory, ...command) {
+    if (!directory) {
+      return Promise.reject(new Error("directory is required"));
+    }
+    if (command.length === 0) {
+      return Promise.reject(new Error("at least one command is required"));
+    }
+    for (const cmd of command) {
+      for (const pattern of FORBIDDEN_PATTERNS) {
+        if (pattern.test(cmd)) {
+          return Promise.reject(
+            new Error(
+              `potentially unsafe command rejected: "${cmd}" matches forbidden pattern ${pattern}`
+            )
+          );
+        }
+      }
+    }
+    return new Promise((resolve, reject) => {
+      const cmd = command.join(" && ");
+      (0, import_child_process.exec)(
+        cmd,
+        { cwd: directory, maxBuffer: 1024 * 1024 * 100 },
+        (err, stdout, stderr) => {
+          if (err) {
+            reject(err);
+            return;
+          }
+          if (stderr) {
+            resolve(stderr);
+            return;
+          }
+          resolve(stdout);
+        }
+      );
+    });
+  }
+  /**
+   * Executes commands and returns the output with newlines stripped.
+   *
+   * @param folder - Working directory for command execution
+   * @param command - One or more command strings to execute
+   * @returns A promise resolving to the cleaned output (no newlines)
+   *
+   * @example
+   * ```typescript
+   * const version = await CommandHelper.runClean('.', 'node --version');
+   * // => "v20.10.0"
+   * ```
+   */
+  static runClean(folder, ...command) {
+    return _CommandHelper.run(folder, ...command).then((result) => {
+      return result ? result.replace(/\r?\n|\r/g, "") : "";
+    });
+  }
+};
+
+// src/param_helper.ts
+var ParamHelper = class {
+  /**
+   * Appends a custom parameter string to `process.argv`.
+   *
+   * @param customParam - The parameter to add (e.g., `'--env=production'`)
+   */
+  static addCustomParam(customParam) {
+    process.argv.push(customParam);
+  }
+  /**
+   * Retrieves the command-line argument at the given index.
+   *
+   * @param index - Zero-based index into `process.argv`
+   * @returns The argument at the given index, or `''` if out of bounds
+   */
+  static getCommandByIndex(index) {
+    return process.argv.length > index ? process.argv[index] : "";
+  }
+  /**
+   * Parses all `--key=value` parameters from `process.argv` into an object.
+   * Surrounding quotes on values are stripped automatically.
+   *
+   * @returns An object mapping parameter names to their string values
+   *
+   * @example
+   * ```typescript
+   * // node script.js --name=Alice --port=3000
+   * ParamHelper.getParams();
+   * // => { name: "Alice", port: "3000" }
+   * ```
+   */
+  static getParams() {
+    const paramsObj = {};
+    process.argv.slice(2).forEach((element) => {
+      const matches = element.match("--([a-zA-Z0-9]+)=(.*)");
+      if (matches) {
+        paramsObj[matches[1]] = matches[2].replace(/^['"]/, "").replace(/['"]$/, "");
+      }
+    });
+    return paramsObj;
+  }
+};
+
+// src/handlebars_helper.ts
+var import_handlebars = __toESM(require("handlebars"), 1);
+var HandlebarsHelper = class {
+  static render(source, data, options) {
+    return new Promise((resolve, reject) => {
+      try {
+        const template = import_handlebars.default.compile(source, options);
+        const res = template(data);
+        resolve(res);
+      } catch (error) {
+        reject(error);
+      }
+    });
+  }
+  static renderFile(fileName, data, options) {
+    return new Promise((resolve, reject) => {
+      try {
+        const source = FileHelper.readFileToString(fileName);
+        const template = import_handlebars.default.compile(source, options);
+        const res = template(data);
+        resolve(res);
+      } catch (error) {
+        reject(error);
+      }
+    });
+  }
+};
+
+// src/ejs_helper.ts
+var import_ejs = __toESM(require("ejs"), 1);
+var EjsHelper = class {
+  static render(source, data, options) {
+    return new Promise((resolve, reject) => {
+      try {
+        const template = import_ejs.default.render(source, data, options);
+        resolve(template);
+      } catch (error) {
+        reject(error);
+      }
+    });
+  }
+  static renderFile(fileName, data, options) {
+    return new Promise((resolve, reject) => {
+      import_ejs.default.renderFile(fileName, data, options ?? {}, (err, str) => {
+        if (err) {
+          reject(err);
+          return;
+        }
+        resolve(str);
+      });
+    });
+  }
+};
+
+// src/pug_helper.ts
+var import_pug = __toESM(require("pug"), 1);
+var PugHelper = class {
+  static render(source, data, options) {
+    return new Promise((resolve, reject) => {
+      try {
+        const template = import_pug.default.compile(source, options);
+        resolve(template(data));
+      } catch (error) {
+        reject(error);
+      }
+    });
+  }
+  static renderFile(fileName, data, options) {
+    return new Promise((resolve, reject) => {
+      try {
+        const template = import_pug.default.compileFile(fileName, options);
+        resolve(template(data));
+      } catch (error) {
+        reject(error);
+      }
+    });
+  }
+};
+
+// src/template_handlers.ts
+var TEMPLATE_HANDLERS = {
+  HANDLEBARS: "HANDLEBARS",
+  EJS: "EJS",
+  PUG: "PUG"
+};
+
+// src/template_builder.ts
+var builtInEngines = {
+  [TEMPLATE_HANDLERS.HANDLEBARS]: HandlebarsHelper,
+  [TEMPLATE_HANDLERS.EJS]: EjsHelper,
+  [TEMPLATE_HANDLERS.PUG]: PugHelper
+};
+var customEngines = {};
+var TemplateBuilder = class {
+  templateHandler;
+  /**
+   * Creates a new TemplateBuilder for the specified engine.
+   *
+   * @param templateHandler - The engine name (e.g., `'EJS'`, `'HANDLEBARS'`, `'PUG'`, or a custom name)
+   */
+  constructor(templateHandler) {
+    this.templateHandler = templateHandler;
+  }
+  /**
+   * Registers a custom template engine that can be used with `new TemplateBuilder(name)`.
+   *
+   * @param name - A unique name for the engine
+   * @param engine - An object implementing the {@link TemplateEngine} interface
+   * @throws If `name` is empty or `engine` doesn't implement `render()` and `renderFile()`
+   *
+   * @example
+   * ```typescript
+   * TemplateBuilder.registerEngine('nunjucks', {
+   *   render: async (source, data) => nunjucks.renderString(source, data),
+   *   renderFile: async (file, data) => nunjucks.render(file, data),
+   * });
+   * ```
+   */
+  static registerEngine(name, engine) {
+    if (!name || typeof name !== "string") {
+      throw new Error("engine name must be a non-empty string");
+    }
+    if (!engine || typeof engine.render !== "function" || typeof engine.renderFile !== "function") {
+      throw new Error("engine must implement render() and renderFile() methods");
+    }
+    customEngines[name] = engine;
+  }
+  /**
+   * Retrieves a registered engine by name (custom engines take precedence over built-in).
+   *
+   * @param name - The engine name to look up
+   * @returns The engine implementation, or `undefined` if not found
+   */
+  static getEngine(name) {
+    return customEngines[name] ?? builtInEngines[name];
+  }
+  /**
+   * Returns an array of all registered engine names (built-in + custom).
+   *
+   * @returns Array of engine name strings
+   *
+   * @example
+   * ```typescript
+   * TemplateBuilder.getRegisteredEngines();
+   * // => ['HANDLEBARS', 'EJS', 'PUG']
+   * ```
+   */
+  static getRegisteredEngines() {
+    return [
+      ...Object.keys(builtInEngines),
+      ...Object.keys(customEngines)
+    ];
+  }
+  resolveEngine() {
+    const engine = customEngines[this.templateHandler] ?? builtInEngines[this.templateHandler] ?? builtInEngines[TEMPLATE_HANDLERS.HANDLEBARS];
+    return engine;
+  }
+  /**
+   * Renders a template from a source string.
+   *
+   * @param source - The template source string
+   * @param data - Data object to pass to the template
+   * @param options - Optional engine-specific options
+   * @returns A promise resolving to the rendered string
+   */
+  render(source, data, options) {
+    return this.resolveEngine().render(source, data, options);
+  }
+  /**
+   * Renders a template from a file path.
+   *
+   * @param fileName - Path to the template file
+   * @param data - Data object to pass to the template
+   * @param options - Optional engine-specific options
+   * @returns A promise resolving to the rendered string
+   */
+  renderFile(fileName, data, options) {
+    return this.resolveEngine().renderFile(fileName, data, options);
+  }
+};
+
+// src/pipeline.ts
+var import_fs2 = __toESM(require("fs"), 1);
+var import_path2 = __toESM(require("path"), 1);
+var Pipeline = class {
+  content = null;
+  contentPromise = null;
+  transforms = [];
+  /**
+   * Sets the pipeline content from a raw string.
+   *
+   * @param source - The string content
+   * @returns This pipeline instance for chaining
+   */
+  fromString(source) {
+    this.content = source;
+    this.contentPromise = null;
+    return this;
+  }
+  /**
+   * Sets the pipeline content by reading a file synchronously.
+   *
+   * @param filePath - Path to the file to read
+   * @returns This pipeline instance for chaining
+   */
+  fromFile(filePath) {
+    this.content = import_fs2.default.readFileSync(filePath, "utf8");
+    this.contentPromise = null;
+    return this;
+  }
+  /**
+   * Sets the pipeline content by rendering a template file.
+   * If no engine is specified, it is auto-detected from the file extension.
+   *
+   * @param templatePath - Path to the template file
+   * @param data - Data to pass to the template
+   * @param engine - Template engine name (auto-detected if omitted)
+   * @param options - Optional engine-specific options
+   * @returns This pipeline instance for chaining
+   */
+  fromTemplate(templatePath, data, engine, options) {
+    const ext = engine ?? extToEngine(templatePath);
+    const builder = new TemplateBuilder(ext);
+    this.contentPromise = builder.renderFile(templatePath, data, options);
+    this.content = null;
+    return this;
+  }
+  /**
+   * Sets the pipeline content by rendering a template from a source string.
+   *
+   * @param source - The template source string
+   * @param data - Data to pass to the template
+   * @param engine - The template engine name
+   * @param options - Optional engine-specific options
+   * @returns This pipeline instance for chaining
+   */
+  fromTemplateString(source, data, engine, options) {
+    const builder = new TemplateBuilder(engine);
+    this.contentPromise = builder.render(source, data, options);
+    this.content = null;
+    return this;
+  }
+  /**
+   * Adds a transformation function to the pipeline.
+   * Transforms are executed sequentially in the order they are added.
+   *
+   * @param fn - A sync or async function that receives and returns a string
+   * @returns This pipeline instance for chaining
+   */
+  transform(fn) {
+    this.transforms.push(fn);
+    return this;
+  }
+  /**
+   * Executes the pipeline: resolves the content and applies all transforms.
+   *
+   * @returns A promise resolving to the final transformed string
+   * @throws If no content source has been set
+   */
+  async execute() {
+    let result;
+    if (this.contentPromise) {
+      result = await this.contentPromise;
+    } else if (this.content !== null) {
+      result = this.content;
+    } else {
+      throw new Error(
+        "Pipeline has no content. Call fromString(), fromFile(), or fromTemplate() first."
+      );
+    }
+    for (const fn of this.transforms) {
+      result = await fn(result);
+    }
+    return result;
+  }
+  /**
+   * Executes the pipeline and writes the result to a file.
+   * Creates parent directories automatically if they don't exist.
+   *
+   * @param filePath - Path to the output file
+   * @returns A promise resolving to the written content
+   */
+  async writeTo(filePath) {
+    const result = await this.execute();
+    const dir = import_path2.default.dirname(filePath);
+    if (!import_fs2.default.existsSync(dir)) {
+      import_fs2.default.mkdirSync(dir, { recursive: true });
+    }
+    import_fs2.default.writeFileSync(filePath, result, "utf8");
+    return result;
+  }
+};
+function extToEngine(filePath) {
+  const ext = import_path2.default.extname(filePath).toLowerCase();
+  switch (ext) {
+    case ".ejs":
+      return "EJS";
+    case ".hbs":
+    case ".handlebars":
+      return "HANDLEBARS";
+    case ".pug":
+    case ".jade":
+      return "PUG";
+    default:
+      return "HANDLEBARS";
+  }
+}
+
+// src/scaffold.ts
+var import_fs3 = __toESM(require("fs"), 1);
+var import_path3 = __toESM(require("path"), 1);
+var Scaffold = class {
+  /**
+   * Generates files from a scaffold manifest.
+   *
+   * @param options - The scaffold configuration
+   * @returns A promise resolving to a {@link ScaffoldResult} with the list of created files
+   */
+  static async from(options) {
+    const {
+      engine,
+      templateDir,
+      outputDir,
+      variables,
+      structure,
+      dryRun = false
+    } = options;
+    const builder = new TemplateBuilder(engine);
+    const resolvedOutputDir = resolveVariables(outputDir, variables);
+    const createdFiles = [];
+    for (const file of structure) {
+      const templatePath = import_path3.default.join(templateDir, file.template);
+      const outputFileName = resolveVariables(file.output, variables);
+      const outputPath = import_path3.default.join(resolvedOutputDir, outputFileName);
+      if (dryRun) {
+        createdFiles.push(outputPath);
+        continue;
+      }
+      const dir = import_path3.default.dirname(outputPath);
+      if (!import_fs3.default.existsSync(dir)) {
+        import_fs3.default.mkdirSync(dir, { recursive: true });
+      }
+      const content = await builder.renderFile(
+        templatePath,
+        variables,
+        {}
+      );
+      import_fs3.default.writeFileSync(outputPath, content, "utf8");
+      createdFiles.push(outputPath);
+    }
+    return { files: createdFiles, dryRun };
+  }
+};
+function resolveVariables(template, variables) {
+  let result = template;
+  for (const [key, value] of Object.entries(variables)) {
+    result = StringHelper.replace(result, `{{${key}}}`, value);
+  }
+  return result;
+}
+
+// src/watcher.ts
+var import_fs4 = __toESM(require("fs"), 1);
+var import_path4 = __toESM(require("path"), 1);
+var Watcher = class {
+  options;
+  abortController = null;
+  /**
+   * Creates a new Watcher instance.
+   *
+   * @param options - Watcher configuration
+   */
+  constructor(options) {
+    this.options = {
+      extensions: [".ejs", ".hbs", ".handlebars", ".pug"],
+      ...options
+    };
+  }
+  /**
+   * Starts watching the template directory for changes.
+   * Does nothing if the watcher is already running.
+   */
+  start() {
+    if (this.abortController) {
+      return;
+    }
+    this.abortController = new AbortController();
+    const { signal } = this.abortController;
+    if (!import_fs4.default.existsSync(this.options.outputDir)) {
+      import_fs4.default.mkdirSync(this.options.outputDir, { recursive: true });
+    }
+    try {
+      const watcher = import_fs4.default.watch(this.options.templateDir, {
+        recursive: true,
+        signal
+      });
+      watcher.on("change", (_eventType, filename) => {
+        if (!filename) return;
+        const filePath = import_path4.default.join(
+          this.options.templateDir,
+          filename.toString()
+        );
+        this.handleChange(filePath);
+      });
+      watcher.on("error", (err) => {
+        if (err.code !== "ABORT_ERR") {
+          this.options.onError?.(err, "");
+        }
+      });
+    } catch {
+    }
+  }
+  /**
+   * Stops watching for changes and cleans up resources.
+   */
+  stop() {
+    if (this.abortController) {
+      this.abortController.abort();
+      this.abortController = null;
+    }
+  }
+  /**
+   * Whether the watcher is currently active.
+   */
+  get isRunning() {
+    return this.abortController !== null;
+  }
+  async handleChange(filePath) {
+    const ext = import_path4.default.extname(filePath).toLowerCase();
+    if (!this.options.extensions.includes(ext)) {
+      return;
+    }
+    if (!import_fs4.default.existsSync(filePath)) {
+      return;
+    }
+    try {
+      const builder = new TemplateBuilder(this.options.engine);
+      const content = await builder.renderFile(
+        filePath,
+        this.options.variables,
+        {}
+      );
+      const relativePath = import_path4.default.relative(this.options.templateDir, filePath);
+      const outputName = relativePath.replace(ext, ".html");
+      const outputPath = import_path4.default.join(this.options.outputDir, outputName);
+      const outputDir = import_path4.default.dirname(outputPath);
+      if (!import_fs4.default.existsSync(outputDir)) {
+        import_fs4.default.mkdirSync(outputDir, { recursive: true });
+      }
+      import_fs4.default.writeFileSync(outputPath, content, "utf8");
+      this.options.onRebuild?.(outputPath);
+    } catch (error) {
+      this.options.onError?.(error, filePath);
+    }
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CommandHelper,
+  FileHelper,
+  ParamHelper,
+  Pipeline,
+  Scaffold,
+  StringHelper,
+  TEMPLATE_HANDLERS,
+  TemplateBuilder,
+  Watcher
+});
+//# sourceMappingURL=index.cjs.map