@sectui/operations 0.0.0-stage → 0.1.0

package/src/registry.ts

@@ -0,0 +1,152 @@
+import { checkArg } from "./args.ts";
+import { OperationError } from "./errors.ts";
+import type { ArgDefs, ArgValues, Operation } from "./operation.ts";
+import { fromBase32, toBase32 } from "./operations/base/base32.ts";
+import { fromBase58, toBase58 } from "./operations/base/base58.ts";
+import { fromBase62, toBase62 } from "./operations/base/base62.ts";
+import { fromBase64, toBase64 } from "./operations/base/base64.ts";
+import { fromBase64url, toBase64url } from "./operations/base/base64url.ts";
+import { hexToRgb } from "./operations/color/hex-to-rgb.ts";
+import { jsonFormat } from "./operations/data/json-format.ts";
+import { jsonToYaml, yamlToJson } from "./operations/data/yaml.ts";
+import { extractEmails, extractIps, extractUrls } from "./operations/extract/extract.ts";
+import { bcrypt } from "./operations/hash/bcrypt.ts";
+import { md5, sha1, sha224, sha256, sha384, sha3_224, sha3_256, sha3_384, sha3_512, sha512 } from "./operations/hash/hashes.ts";
+import { fromHex } from "./operations/hex/from-hex.ts";
+import { toHex } from "./operations/hex/to-hex.ts";
+import { htmlDecode } from "./operations/html/html-decode.ts";
+import { htmlEncode } from "./operations/html/html-encode.ts";
+import {
+  toCamelCase,
+  toKebabCase,
+  toLowerCase,
+  toPascalCase,
+  toSlug,
+  toSnakeCase,
+  toTitleCase,
+  toUpperCase,
+} from "./operations/text/case.ts";
+import { countChars, countLines, countWords } from "./operations/text/count.ts";
+import { addLineNumbers, reverseLines, shuffleLines, sortLines, uniqueLines } from "./operations/text/line-operations.ts";
+import { escapeQuotes, removeNewlines, removeWhitespace, reverseText } from "./operations/text/text-operations.ts";
+import { urlDecode } from "./operations/url/url-decode.ts";
+import { urlEncode } from "./operations/url/url-encode.ts";
+
+/** Every new operation must be registered here. */
+export const operations = [
+  // Encoding
+  toBase64,
+  fromBase64,
+  toBase64url,
+  fromBase64url,
+  toBase32,
+  fromBase32,
+  toBase58,
+  fromBase58,
+  toBase62,
+  fromBase62,
+  toHex,
+  fromHex,
+  urlEncode,
+  urlDecode,
+  htmlEncode,
+  htmlDecode,
+  // Hashing
+  md5,
+  sha1,
+  sha224,
+  sha256,
+  sha384,
+  sha512,
+  sha3_224,
+  sha3_256,
+  sha3_384,
+  sha3_512,
+  bcrypt,
+  // Data format
+  jsonFormat,
+  jsonToYaml,
+  yamlToJson,
+  hexToRgb,
+  // Text
+  toLowerCase,
+  toUpperCase,
+  toTitleCase,
+  toCamelCase,
+  toPascalCase,
+  toSnakeCase,
+  toKebabCase,
+  toSlug,
+  sortLines,
+  shuffleLines,
+  uniqueLines,
+  reverseLines,
+  addLineNumbers,
+  reverseText,
+  removeNewlines,
+  removeWhitespace,
+  escapeQuotes,
+  countChars,
+  countLines,
+  countWords,
+  // Extractors
+  extractIps,
+  extractEmails,
+  extractUrls,
+] as const;
+
+type AnyOperation = (typeof operations)[number];
+export type OperationId = AnyOperation["id"];
+export type ArgsOf<Id extends OperationId> = ArgValues<Extract<AnyOperation, { id: Id }>["args"]>;
+
+// Compile-time check: a typo in an `inverse` shows up here with the unknown id.
+type UnknownInverse = Exclude<NonNullable<AnyOperation["inverse"]>, OperationId>;
+const inversesExist: [UnknownInverse] extends [never] ? true : UnknownInverse = true;
+void inversesExist;
+
+const byId = new Map<string, Operation>(operations.map((op) => [op.id, op as unknown as Operation]));
+
+export function isOperationId(id: string): id is OperationId {
+  return byId.has(id);
+}
+
+export function getOperation(id: OperationId): Operation {
+  return byId.get(id)!;
+}
+
+function resolveArgs(op: Operation, args: Record<string, unknown>): ArgValues<ArgDefs> {
+  for (const key of Object.keys(args)) {
+    if (!Object.hasOwn(op.args, key)) {
+      const expected = Object.keys(op.args).join(", ") || "none";
+      throw new OperationError(`Unknown argument "${key}" (expected: ${expected})`);
+    }
+  }
+  const resolved: Record<string, unknown> = {};
+  for (const [key, def] of Object.entries(op.args)) {
+    const value = args[key] ?? def.default;
+    try {
+      checkArg(def, key, value);
+    } catch (error) {
+      throw new OperationError((error as Error).message);
+    }
+    resolved[key] = value;
+  }
+  return resolved as ArgValues<ArgDefs>;
+}
+
+/** Throws an `OperationError` tagged with the operation id when the input or arguments are invalid. */
+export function run<Id extends OperationId>(id: Id, input: Uint8Array | string, args: Partial<ArgsOf<Id>> = {}): Uint8Array {
+  const op = getOperation(id);
+  const bytes = typeof input === "string" ? new TextEncoder().encode(input) : input;
+  try {
+    return op.run(bytes, resolveArgs(op, args));
+  } catch (error) {
+    const wrapped = error instanceof OperationError ? error : new OperationError((error as Error).message, { cause: error });
+    wrapped.operation = id;
+    throw wrapped;
+  }
+}
+
+export function runText<Id extends OperationId>(id: Id, input: Uint8Array | string, args: Partial<ArgsOf<Id>> = {}): string {
+  return new TextDecoder().decode(run(id, input, args));
+}

package/src/template.ts

@@ -0,0 +1,214 @@
+import { coerceArg, findArg, kebab } from "./args.ts";
+import { getOperation, isOperationId, run, type OperationId } from "./registry.ts";
+
+// Syntax: `op{content}` or `op(name=value, flag){content}`, nestable.
+// Only known operation ids are interpreted: `{x}`, `foo{x}` or `op(text)` stay plain text.
+// In content, `\{`, `\}` and `\\` produce the literal character.
+// Argument values are bare (`[A-Za-z0-9-_.+/=]`) or quoted with " or ', where
+// `\"`, `\'` and `\\` escape; anything else inside quotes is literal.
+
+export type TemplateNode =
+  | { type: "text"; value: string }
+  | { type: "op"; id: OperationId; args: Record<string, unknown>; children: TemplateNode[]; start: number };
+
+export class TemplateError extends Error {
+  override name = "TemplateError";
+  /** 1-based line and column of `position`. */
+  readonly line: number;
+  readonly column: number;
+  /** Offset in the source. */
+  readonly position: number;
+
+  constructor(message: string, source: string, position: number) {
+    const before = source.slice(0, position);
+    const line = before.split("\n").length;
+    const column = position - before.lastIndexOf("\n");
+    super(`${message} (line ${line}, column ${column})`);
+    this.position = position;
+    this.line = line;
+    this.column = column;
+  }
+}
+
+const OP_START = /([a-z0-9]+(?:-[a-z0-9]+)*)([{(])/y;
+const IDENT_CHAR = /[a-z0-9-]/;
+const ARG_NAME = /[a-z0-9]+(?:-[a-z0-9]+)*/y;
+const BARE_VALUE = /[A-Za-z0-9\-_.+/=]+/y;
+const SPACE = /\s/;
+
+/** Index of the `)` closing an argument list opened before `from`, ignoring quoted parts; -1 if none. */
+function findArgsEnd(source: string, from: number): number {
+  let quote: string | null = null;
+  for (let j = from; j < source.length; j++) {
+    const c = source[j]!;
+    if (quote) {
+      if (c === "\\") j++;
+      else if (c === quote) quote = null;
+    } else if (c === '"' || c === "'") {
+      quote = c;
+    } else if (c === ")") {
+      return j;
+    }
+  }
+  return -1;
+}
+
+function parseArgList(id: OperationId, source: string, from: number, end: number): Record<string, unknown> {
+  const op = getOperation(id);
+  const args: Record<string, unknown> = {};
+  let j = from;
+
+  const skipSpaces = () => {
+    while (j < end && SPACE.test(source[j]!)) j++;
+  };
+  const fail = (message: string, at = j): never => {
+    throw new TemplateError(message, source, at);
+  };
+
+  const parseValue = (): string => {
+    const quote = source[j];
+    if (quote === '"' || quote === "'") {
+      let value = "";
+      for (j++; source[j] !== quote; j++) {
+        if (j >= end) fail("Unterminated quote");
+        if (source[j] === "\\" && (source[j + 1] === quote || source[j + 1] === "\\")) j++;
+        value += source[j];
+      }
+      j++;
+      return value;
+    }
+    BARE_VALUE.lastIndex = j;
+    const match = BARE_VALUE.exec(source);
+    if (!match || BARE_VALUE.lastIndex > end) return fail("Expected a value (use quotes for special characters)");
+    j = BARE_VALUE.lastIndex;
+    return match[0];
+  };
+
+  skipSpaces();
+  while (j < end) {
+    const nameStart = j;
+    ARG_NAME.lastIndex = j;
+    const name = ARG_NAME.exec(source)?.[0];
+    if (!name || ARG_NAME.lastIndex > end) fail("Expected an argument name");
+    j = ARG_NAME.lastIndex;
+
+    const arg = findArg(op, name!);
+    if (!arg) {
+      const expected = Object.keys(op.args).map(kebab).join(", ") || "none";
+      fail(`Unknown argument "${name}" for "${id}" (expected: ${expected})`, nameStart);
+    }
+    const [key, def] = arg!;
+    if (Object.hasOwn(args, key)) fail(`Duplicate argument "${name}"`, nameStart);
+
+    skipSpaces();
+    let raw: string | boolean = true;
+    if (source[j] === "=") {
+      j++;
+      skipSpaces();
+      raw = parseValue();
+    }
+    skipSpaces();
+    if (j < end && source[j] !== ",") fail(`Unexpected "${source[j]}" (use quotes for special characters)`);
+
+    try {
+      args[key] = coerceArg(def, name!, raw);
+    } catch (error) {
+      fail((error as Error).message, nameStart);
+    }
+
+    if (j < end) {
+      j++;
+      skipSpaces();
+      if (j >= end) fail("Expected an argument name");
+    }
+  }
+  return args;
+}
+
+export function parse(source: string): TemplateNode[] {
+  let i = 0;
+
+  function parseNodes(open: { start: number } | null): TemplateNode[] {
+    const nodes: TemplateNode[] = [];
+    let text = "";
+    const flush = () => {
+      if (text) nodes.push({ type: "text", value: text });
+      text = "";
+    };
+
+    while (i < source.length) {
+      const ch = source[i]!;
+
+      if (ch === "\\" && i + 1 < source.length && "{}\\".includes(source[i + 1]!)) {
+        text += source[i + 1];
+        i += 2;
+        continue;
+      }
+
+      if (ch === "}" && open) {
+        i++;
+        flush();
+        return nodes;
+      }
+
+      if (i === 0 || !IDENT_CHAR.test(source[i - 1]!)) {
+        OP_START.lastIndex = i;
+        const match = OP_START.exec(source);
+        const id = match?.[1];
+        if (id && isOperationId(id)) {
+          let args: Record<string, unknown> = {};
+          let contentStart = OP_START.lastIndex;
+          const argsEnd = match![2] === "(" ? findArgsEnd(source, contentStart) : -1;
+          const isBlock = match![2] === "{" || (argsEnd >= 0 && source[argsEnd + 1] === "{");
+          if (isBlock) {
+            if (argsEnd >= 0) {
+              args = parseArgList(id, source, contentStart, argsEnd);
+              contentStart = argsEnd + 2;
+            }
+            flush();
+            const start = i;
+            i = contentStart;
+            nodes.push({ type: "op", id, args, children: parseNodes({ start }), start });
+            continue;
+          }
+        }
+      }
+
+      text += ch;
+      i++;
+    }
+
+    if (open) throw new TemplateError("Missing closing brace", source, open.start);
+    flush();
+    return nodes;
+  }
+
+  return parseNodes(null);
+}
+
+function evaluate(nodes: TemplateNode[], source: string): Uint8Array {
+  const parts = nodes.map((node) => {
+    if (node.type === "text") return new TextEncoder().encode(node.value);
+    const input = evaluate(node.children, source);
+    try {
+      return run(node.id, input, node.args as never);
+    } catch (error) {
+      throw new TemplateError(`${node.id}: ${(error as Error).message}`, source, node.start);
+    }
+  });
+  const out = new Uint8Array(parts.reduce((n, p) => n + p.length, 0));
+  let offset = 0;
+  for (const part of parts) {
+    out.set(part, offset);
+    offset += part.length;
+  }
+  return out;
+}
+
+export function renderBytes(source: string): Uint8Array {
+  return evaluate(parse(source), source);
+}
+
+export function render(source: string): string {
+  return new TextDecoder().decode(renderBytes(source));
+}