@tiveor/scg 0.2.0 → 0.5.0

package/dist/cli.cjs

@@ -0,0 +1,779 @@
+#!/usr/bin/env node
+"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 __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
+));
+
+// src/cli.ts
+var import_fs3 = __toESM(require("fs"), 1);
+var import_path3 = __toESM(require("path"), 1);
+
+// src/handlebars_helper.ts
+var import_handlebars = __toESM(require("handlebars"), 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);
+
+// 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 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/handlebars_helper.ts
+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/scaffold.ts
+var import_fs2 = __toESM(require("fs"), 1);
+var import_path2 = __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_path2.default.join(templateDir, file.template);
+      const outputFileName = resolveVariables(file.output, variables);
+      const outputPath = import_path2.default.join(resolvedOutputDir, outputFileName);
+      if (dryRun) {
+        createdFiles.push(outputPath);
+        continue;
+      }
+      const dir = import_path2.default.dirname(outputPath);
+      if (!import_fs2.default.existsSync(dir)) {
+        import_fs2.default.mkdirSync(dir, { recursive: true });
+      }
+      const content = await builder.renderFile(
+        templatePath,
+        variables,
+        {}
+      );
+      import_fs2.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/cli.ts
+var args = process.argv.slice(2);
+var command = args[0];
+function parseFlags(args2) {
+  const flags = {};
+  for (const arg of args2) {
+    const match = arg.match(/^--([a-zA-Z0-9_-]+)=(.*)$/);
+    if (match) {
+      flags[match[1]] = match[2].replace(/^['"]/, "").replace(/['"]$/, "");
+    }
+  }
+  return flags;
+}
+function printHelp() {
+  console.log(`
+SCG - Simple Code Generator
+
+Usage:
+  scg <command> [options]
+
+Commands:
+  init                    Initialize a scaffold manifest (scaffold.json)
+  generate                Generate files from a scaffold manifest
+  render <template>       Render a single template file
+
+Options:
+  --manifest=<path>       Path to scaffold manifest (default: scaffold.json)
+  --vars=<key=val,...>    Comma-separated variables (e.g. name=Button,style=module)
+  --data=<json>           JSON data for template rendering
+  --engine=<name>         Template engine (EJS, HANDLEBARS, PUG)
+  --output=<path>         Output file path (for render command)
+  --dry-run               Preview without writing files
+
+Examples:
+  scg init
+  scg generate --manifest=scaffold.json --vars=name=Button
+  scg render template.ejs --data='{"name": "World"}'
+  scg render template.ejs --data='{"name": "World"}' --output=output.html
+`);
+}
+function parseVars(varsStr) {
+  const vars = {};
+  for (const pair of varsStr.split(",")) {
+    const [key, ...rest] = pair.split("=");
+    if (key && rest.length > 0) {
+      vars[key.trim()] = rest.join("=").trim();
+    }
+  }
+  return vars;
+}
+async function cmdInit() {
+  const manifest = {
+    engine: "EJS",
+    templateDir: "./templates",
+    outputDir: "./generated/{{name}}",
+    variables: { name: "MyComponent" },
+    structure: [
+      { template: "component.ejs", output: "{{name}}.tsx" },
+      { template: "test.ejs", output: "{{name}}.test.tsx" },
+      { template: "index.ejs", output: "index.ts" }
+    ]
+  };
+  const filePath = "scaffold.json";
+  import_fs3.default.writeFileSync(filePath, JSON.stringify(manifest, null, 2), "utf8");
+  console.log(`Created ${filePath}`);
+  console.log("Edit the manifest and run: scg generate");
+}
+async function cmdGenerate() {
+  const flags = parseFlags(args);
+  const manifestPath = flags["manifest"] ?? "scaffold.json";
+  const dryRun = args.includes("--dry-run");
+  if (!import_fs3.default.existsSync(manifestPath)) {
+    console.error(`Manifest not found: ${manifestPath}`);
+    console.error('Run "scg init" to create one.');
+    process.exit(1);
+  }
+  const manifest = JSON.parse(
+    import_fs3.default.readFileSync(manifestPath, "utf8")
+  );
+  if (flags["vars"]) {
+    Object.assign(manifest.variables, parseVars(flags["vars"]));
+  }
+  manifest.dryRun = dryRun;
+  const result = await Scaffold.from(manifest);
+  if (dryRun) {
+    console.log("Dry run - files that would be created:");
+  } else {
+    console.log("Generated files:");
+  }
+  for (const file of result.files) {
+    console.log(`  ${file}`);
+  }
+}
+async function cmdRender() {
+  const templatePath = args[1];
+  if (!templatePath) {
+    console.error("Usage: scg render <template> [--data=<json>] [--engine=<name>] [--output=<path>]");
+    process.exit(1);
+  }
+  const flags = parseFlags(args);
+  const engine = flags["engine"] ?? extToEngine(templatePath);
+  const dataStr = flags["data"] ?? "{}";
+  const outputPath = flags["output"];
+  let data;
+  try {
+    data = JSON.parse(dataStr);
+  } catch {
+    console.error("Invalid JSON in --data flag");
+    process.exit(1);
+  }
+  const builder = new TemplateBuilder(engine);
+  const result = await builder.renderFile(templatePath, data, {});
+  if (outputPath) {
+    const dir = import_path3.default.dirname(outputPath);
+    if (!import_fs3.default.existsSync(dir)) {
+      import_fs3.default.mkdirSync(dir, { recursive: true });
+    }
+    import_fs3.default.writeFileSync(outputPath, result, "utf8");
+    console.log(`Written to ${outputPath}`);
+  } else {
+    console.log(result);
+  }
+}
+function extToEngine(filePath) {
+  const ext = import_path3.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";
+  }
+}
+async function main() {
+  switch (command) {
+    case "init":
+      await cmdInit();
+      break;
+    case "generate":
+      await cmdGenerate();
+      break;
+    case "render":
+      await cmdRender();
+      break;
+    case "--help":
+    case "-h":
+    case void 0:
+      printHelp();
+      break;
+    default:
+      console.error(`Unknown command: ${command}`);
+      printHelp();
+      process.exit(1);
+  }
+}
+main().catch((err) => {
+  console.error(err.message);
+  process.exit(1);
+});
+//# sourceMappingURL=cli.cjs.map