create-monolayer-app 0.2.2 → 0.4.0

package/template/vendor/file-bucket/xml.ts

@@ -0,0 +1,325 @@
+/**
+ * Zero-dependency XML parser, DOM builder, and serializer for S3 XML payloads.
+ */
+
+// oxlint-disable-next-line max-classes-per-file
+export const S3_NS = "http://s3.amazonaws.com/doc/2006-03-01/";
+export const XML_DECL = '<?xml version="1.0" encoding="UTF-8"?>';
+
+export class ParseError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = "ParseError";
+  }
+}
+
+export function escapeXml(
+  str: string | number | boolean | null | undefined
+): string {
+  if (str === null || str === undefined) return "";
+  return String(str)
+    .replaceAll("&", "&amp;")
+    .replaceAll("<", "&lt;")
+    .replaceAll(">", "&gt;")
+    .replaceAll('"', "&quot;")
+    .replaceAll("'", "&apos;");
+}
+
+export function unescapeXml(str: string): string {
+  return str
+    .replaceAll("&quot;", '"')
+    .replaceAll("&apos;", "'")
+    .replaceAll("&lt;", "<")
+    .replaceAll("&gt;", ">")
+    .replaceAll("&amp;", "&")
+    .replaceAll(/&#(\d+);/gu, (_, dec) =>
+      String.fromCodePoint(Math.trunc(Number(dec)))
+    )
+    .replaceAll(/&#x([0-9a-fA-F]+);/gu, (_, hex) =>
+      String.fromCodePoint(Number.parseInt(hex, 16))
+    );
+}
+
+/**
+ * Strips namespace prefix or Clark notation from a tag name.
+ * e.g. "{http://...}Rule" -> "Rule", "s3:Rule" -> "Rule", "Rule" -> "Rule"
+ */
+export function localTagName(tag: string): string {
+  if (tag.startsWith("{")) {
+    const idx = tag.indexOf("}");
+    if (idx !== -1) return tag.slice(idx + 1);
+  }
+  const colonIdx = tag.indexOf(":");
+  if (colonIdx !== -1) {
+    return tag.slice(colonIdx + 1);
+  }
+  return tag;
+}
+
+function isString(
+  value: string | Record<string, string> | undefined
+): value is string {
+  return typeof value === "string";
+}
+
+export class XmlElement {
+  public tag: string;
+  public attrs: Record<string, string>;
+  public text?: string;
+  public children: XmlElement[];
+
+  constructor(tag: string, attrs: Record<string, string> = {}, text?: string) {
+    this.tag = tag;
+    this.attrs = { ...attrs };
+    this.text = text;
+    this.children = [];
+  }
+
+  public localName(): string {
+    return localTagName(this.tag);
+  }
+
+  public subElement(
+    tag: string,
+    textOrAttrs?: string | Record<string, string>,
+    text?: string
+  ): XmlElement {
+    const el = isString(textOrAttrs)
+      ? new XmlElement(tag, {}, textOrAttrs)
+      : new XmlElement(tag, textOrAttrs || {}, text);
+
+    this.children.push(el);
+    return el;
+  }
+
+  public find(tag: string): XmlElement | undefined {
+    const targetLocal = localTagName(tag);
+    return this.children.find(
+      (c) => c.tag === tag || c.localName() === targetLocal
+    );
+  }
+
+  public findAll(tag: string): XmlElement[] {
+    const targetLocal = localTagName(tag);
+    return this.children.filter(
+      (c) => c.tag === tag || c.localName() === targetLocal
+    );
+  }
+
+  public findText(tag: string): string | undefined {
+    const el = this.find(tag);
+    return el?.text;
+  }
+
+  public findDescendant(tag: string): XmlElement | undefined {
+    const targetLocal = localTagName(tag);
+    for (const c of this.children) {
+      if (c.tag === tag || c.localName() === targetLocal) {
+        return c;
+      }
+      const deep = c.findDescendant(tag);
+      if (deep) return deep;
+    }
+    return undefined;
+  }
+
+  public findAllDescendants(tag: string): XmlElement[] {
+    const targetLocal = localTagName(tag);
+    const result: XmlElement[] = [];
+    for (const c of this.children) {
+      if (c.tag === tag || c.localName() === targetLocal) {
+        result.push(c);
+      }
+      result.push(...c.findAllDescendants(tag));
+    }
+    return result;
+  }
+
+  public iter(): XmlElement[] {
+    const result: XmlElement[] = [this];
+    for (const child of this.children) {
+      result.push(...child.iter());
+    }
+    return result;
+  }
+
+  public toXml(includeDeclaration = false): string {
+    let s = includeDeclaration ? `${XML_DECL}\n` : "";
+    s += `<${this.tag}`;
+    for (const [k, v] of Object.entries(this.attrs)) {
+      s += ` ${k}="${escapeXml(v)}"`;
+    }
+    if (this.children.length === 0 && this.text === undefined) {
+      s += "/>";
+      return s;
+    }
+    s += ">";
+    if (this.text !== undefined) {
+      s += escapeXml(this.text);
+    }
+    for (const child of this.children) {
+      s += child.toXml(false);
+    }
+    s += `</${this.tag}>`;
+    return s;
+  }
+}
+
+export function subElement(
+  parent: XmlElement,
+  tag: string,
+  textOrAttrs?: string | Record<string, string>,
+  text?: string
+): XmlElement {
+  return parent.subElement(tag, textOrAttrs, text);
+}
+
+// oxlint-disable-next-line complexity
+export function parseXml(xml: string | Buffer): XmlElement {
+  // String inputs are also used by browser upload handles.
+  // oxlint-disable-next-line anti-slop/no-runtime-typeof
+  let str = (typeof xml === "string" ? xml : xml.toString("utf-8")).trim();
+  if (!str) {
+    throw new ParseError("Empty XML document");
+  }
+
+  // Strip XML declaration if present
+  if (str.startsWith("<?xml")) {
+    const end = str.indexOf("?>");
+    if (end !== -1) {
+      str = str.slice(end + 2).trim();
+    }
+  }
+
+  let pos = 0;
+  const len = str.length;
+  let root: XmlElement | null = null;
+  const stack: XmlElement[] = [];
+
+  while (pos < len) {
+    const lt = str.indexOf("<", pos);
+    if (lt === -1) {
+      if (stack.length > 0) {
+        const text = unescapeXml(str.slice(pos).trim());
+        const top = stack.at(-1);
+        if (text && top) {
+          top.text = (top.text || "") + text;
+        }
+      }
+      break;
+    }
+
+    if (lt > pos && stack.length > 0) {
+      const text = unescapeXml(str.slice(pos, lt).trim());
+      const top = stack.at(-1);
+      if (text && top) {
+        top.text = (top.text || "") + text;
+      }
+    }
+
+    pos = lt + 1;
+
+    // Comment
+    if (str.startsWith("!--", pos)) {
+      const end = str.indexOf("-->", pos + 3);
+      pos = end === -1 ? len : end + 3;
+      continue;
+    }
+
+    // CDATA
+    if (str.startsWith("![CDATA[", pos)) {
+      const end = str.indexOf("]]>", pos + 8);
+      const cdata = end === -1 ? str.slice(pos + 8) : str.slice(pos + 8, end);
+      const top = stack.at(-1);
+      if (top) {
+        top.text = (top.text || "") + cdata;
+      }
+      pos = end === -1 ? len : end + 3;
+      continue;
+    }
+
+    // Processing instructions or DOCTYPE
+    if (str.startsWith("?", pos) || str.startsWith("!", pos)) {
+      const gt = str.indexOf(">", pos);
+      pos = gt === -1 ? len : gt + 1;
+      continue;
+    }
+
+    // Closing tag: </tag>
+    if (str[pos] === "/") {
+      const gt = str.indexOf(">", pos);
+      if (gt === -1) throw new ParseError("Unclosed closing tag");
+      const closeTag = str.slice(pos + 1, gt).trim();
+      const open = stack.pop();
+      if (!open) {
+        throw new ParseError(`Unexpected closing tag: </${closeTag}>`);
+      }
+      if (
+        localTagName(open.tag) !== localTagName(closeTag) &&
+        open.tag !== closeTag
+      ) {
+        throw new ParseError(
+          `Mismatched closing tag: expected </${open.tag}>, got </${closeTag}>`
+        );
+      }
+      pos = gt + 1;
+      continue;
+    }
+
+    // Opening tag: <tag ...>
+    const gt = str.indexOf(">", pos);
+    if (gt === -1) {
+      throw new ParseError("Unclosed opening tag");
+    }
+
+    let tagBody = str.slice(pos, gt).trim();
+    const selfClosing = tagBody.endsWith("/");
+    if (selfClosing) {
+      tagBody = tagBody.slice(0, -1).trim();
+    }
+
+    const spaceIdx = tagBody.search(/\s/u);
+    const tagName = spaceIdx === -1 ? tagBody : tagBody.slice(0, spaceIdx);
+    const attrs: Record<string, string> = {};
+
+    if (spaceIdx !== -1) {
+      const attrStr = tagBody.slice(spaceIdx).trim();
+      const attrRegex =
+        /([a-zA-Z0-9_:.-]+)\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s>]+))/gu;
+      let m: RegExpExecArray | null;
+      while ((m = attrRegex.exec(attrStr)) !== null) {
+        attrs[m[1]] = unescapeXml(m[2] ?? m[3] ?? m[4] ?? "");
+      }
+    }
+
+    const el = new XmlElement(tagName, attrs);
+    const top = stack.at(-1);
+    if (top) {
+      top.children.push(el);
+    } else {
+      if (root) {
+        throw new ParseError("Multiple root elements found in XML document");
+      }
+      root = el;
+    }
+
+    if (!selfClosing) {
+      stack.push(el);
+    }
+    pos = gt + 1;
+  }
+
+  const lastUnclosed = stack.at(-1);
+  if (lastUnclosed) {
+    throw new ParseError(`Unclosed element: <${lastUnclosed.tag}>`);
+  }
+  if (!root) {
+    throw new ParseError("Empty XML document");
+  }
+
+  return root;
+}
+
+export function xmlBody(root: XmlElement): Buffer {
+  return Buffer.from(`${XML_DECL}\n${root.toXml(false)}`, "utf-8");
+}

package/template/vendor/package-app/package-app.mjs

@@ -0,0 +1,116 @@
+import { spawnSync } from "node:child_process";
+import { existsSync, mkdirSync, readFileSync, rmSync } from "node:fs";
+import path from "node:path";
+import process from "node:process";
+import { pathToFileURL } from "node:url";
+
+const DEFAULT_OUTPUT_DIR = "build";
+const DEFAULT_GITIGNORE = ".gitignore";
+const DEFAULT_EXCLUDES = [".git", "build"];
+
+/**
+ * Resolves the package name from package.json in the target directory.
+ *
+ * @param {string} cwd - The project root directory.
+ * @returns {string} Sanitized package name or fallback "app".
+ */
+function getPackageName(cwd) {
+  const packageJsonPath = path.resolve(cwd, "package.json");
+  if (existsSync(packageJsonPath)) {
+    try {
+      const pkg = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
+      // oxlint-disable-next-line anti-slop/no-runtime-typeof
+      if (typeof pkg.name === "string" && pkg.name.trim()) {
+        return pkg.name.trim().replace(/^@/u, "").replaceAll("/", "-");
+      }
+    } catch {
+      // Ignore parse errors and use fallback
+    }
+  }
+  return "app";
+}
+
+/**
+ * Packages the current application directory into a timestamped tar.gz archive:
+ * `<package-name>-<timestamp>.tar.gz`
+ * Cleans and recreates the output directory before packaging.
+ *
+ * @param {Object} [options] - Configuration options for packaging.
+ * @param {string} [options.cwd] - The project root directory. Defaults to `process.cwd()`.
+ * @param {string} [options.outputDirectory] - Output directory relative to `cwd`. Defaults to `"build"`.
+ * @param {string} [options.packageName] - Custom package name override. Defaults to name from `package.json`.
+ * @param {number} [options.timestamp] - Custom timestamp for the archive filename. Defaults to `Date.now()`.
+ * @param {string[]} [options.excludes] - Patterns to exclude from the archive.
+ * @param {string} [options.gitignorePath] - Gitignore file path relative to `cwd`. Defaults to `".gitignore"`.
+ * @returns {{ archiveName: string, relativePath: string, absolutePath: string, packageName: string }} Details of the generated archive.
+ */
+export function packageApp(options = {}) {
+  const cwd = options.cwd ?? process.cwd();
+  const outputDirectory = options.outputDirectory ?? DEFAULT_OUTPUT_DIR;
+  const targetDir = path.resolve(cwd, outputDirectory);
+
+  // Clean and recreate the output directory
+  if (existsSync(targetDir)) {
+    rmSync(targetDir, { recursive: true, force: true });
+  }
+  mkdirSync(targetDir, { recursive: true });
+
+  const packageName = options.packageName ?? getPackageName(cwd);
+  const timestamp = options.timestamp ?? Date.now();
+  const archiveName = `${timestamp}.tar.gz`;
+  const relativePath = path.posix.join(outputDirectory, archiveName);
+  const absolutePath = path.resolve(cwd, relativePath);
+
+  const gitignoreFile = options.gitignorePath ?? DEFAULT_GITIGNORE;
+  const excludes = options.excludes ?? DEFAULT_EXCLUDES;
+
+  const tarArgs = ["-czf", relativePath];
+
+  const fullGitignorePath = path.resolve(cwd, gitignoreFile);
+  if (existsSync(fullGitignorePath)) {
+    tarArgs.push(`--exclude-from=${gitignoreFile}`);
+  }
+
+  for (const exclude of excludes) {
+    tarArgs.push(`--exclude=${exclude}`);
+  }
+
+  tarArgs.push(".");
+
+  const result = spawnSync("tar", tarArgs, {
+    cwd,
+    stdio: "inherit",
+  });
+
+  if (result.error) {
+    throw result.error;
+  }
+
+  if (result.status !== 0) {
+    throw new Error(`tar process exited with status ${result.status}`);
+  }
+
+  return {
+    archiveName,
+    relativePath,
+    absolutePath,
+    packageName,
+  };
+}
+
+const [, entryPath] = process.argv;
+if (
+  entryPath &&
+  import.meta.url === pathToFileURL(path.resolve(entryPath)).href
+) {
+  try {
+    const result = packageApp();
+    console.log(`Successfully packaged application to ${result.relativePath}`);
+  } catch (error) {
+    console.error(
+      "Failed to package application:",
+      error instanceof Error ? error.message : error
+    );
+    process.exitCode = 1;
+  }
+}