@sectui/operations 0.0.0-stage → 0.1.0

package/src/operations/text/case.ts

@@ -0,0 +1,140 @@
+import { defineOperation } from "../../operation.ts";
+import { mapLines, mapText } from "./lines.ts";
+
+// Words of an identifier or a sentence: "XMLHttpRequest v2" -> XML, Http, Request, v, 2.
+const WORD = /\p{Lu}+(?=\p{Lu}\p{Ll})|\p{Lu}?[\p{Ll}\p{Lo}\p{M}]+|\p{Lu}+\p{M}*|\p{Lt}[\p{Ll}\p{M}]*|\p{N}+/gu;
+
+function words(line: string): string[] {
+  return line.replace(/['’]/g, "").match(WORD) ?? [];
+}
+
+const capitalize = (word: string) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase();
+
+/** Defines an operation that rebuilds each line from its words. */
+function defineCaseOperation<const Id extends string>(
+  id: Id,
+  name: string,
+  description: string,
+  aliases: string[],
+  join: (words: string[]) => string,
+  example: { input: string; output: string },
+) {
+  return defineOperation({
+    id,
+    name,
+    description: `${description} Each line is converted separately.`,
+    category: "Text",
+    output: "binary",
+    aliases,
+    args: {},
+    examples: [example],
+    run: (input) => mapText(input, (text) => mapLines(text, (lines) => lines.map((line) => join(words(line))))),
+  });
+}
+
+export const toCamelCase = defineCaseOperation(
+  "to-camel-case",
+  "To camelCase",
+  'Joins the words with the first one in lowercase and the others capitalized. e.g. "hello world" becomes "helloWorld".',
+  ["camelcase", "lower camel case"],
+  (words) => words.map((word, i) => (i ? capitalize(word) : word.toLowerCase())).join(""),
+  { input: "Hello big_world\nXMLHttpRequest", output: "helloBigWorld\nxmlHttpRequest" },
+);
+
+export const toPascalCase = defineCaseOperation(
+  "to-pascal-case",
+  "To PascalCase",
+  'Joins the capitalized words. e.g. "hello world" becomes "HelloWorld".',
+  ["pascalcase", "upper camel case"],
+  (words) => words.map(capitalize).join(""),
+  { input: "hello big_world", output: "HelloBigWorld" },
+);
+
+export const toSnakeCase = defineCaseOperation(
+  "to-snake-case",
+  "To snake_case",
+  'Joins the lowercase words with underscores. e.g. "helloWorld" becomes "hello_world".',
+  ["snakecase", "underscore"],
+  (words) => words.map((word) => word.toLowerCase()).join("_"),
+  { input: "Hello bigWorld", output: "hello_big_world" },
+);
+
+export const toKebabCase = defineCaseOperation(
+  "to-kebab-case",
+  "To kebab-case",
+  'Joins the lowercase words with hyphens. e.g. "helloWorld" becomes "hello-world".',
+  ["kebabcase", "dash case", "hyphen"],
+  (words) => words.map((word) => word.toLowerCase()).join("-"),
+  { input: "Hello bigWorld", output: "hello-big-world" },
+);
+
+// Letters that Unicode decomposition does not reduce to ASCII.
+const TRANSLITERATIONS: Record<string, string> = { ß: "ss", æ: "ae", œ: "oe", ø: "o", đ: "d", ł: "l", þ: "th", ð: "d" };
+
+export const toSlug = defineOperation({
+  id: "to-slug",
+  name: "To slug",
+  description:
+    'Makes a URL-friendly slug: removes accents, lowercases, and replaces everything but letters and digits with a separator. e.g. "Héllo, World!" becomes "hello-world". Each line is converted separately.',
+  category: "Text",
+  output: "binary",
+  aliases: ["slugify", "permalink"],
+  args: {
+    separator: { type: "string", name: "Separator", default: "-" },
+  },
+  examples: [
+    { input: "Héllo, World!", output: "hello-world" },
+    { input: "Straße & Œuvre", args: { separator: "_" }, output: "strasse_oeuvre" },
+  ],
+  run: (input, { separator }) =>
+    mapText(input, (text) =>
+      mapLines(text, (lines) =>
+        lines.map((line) =>
+          line
+            .toLowerCase()
+            .replace(/[ßæœøđłþð]/g, (ch) => TRANSLITERATIONS[ch]!)
+            .normalize("NFKD")
+            .replace(/\p{M}/gu, "")
+            .replace(/[^a-z0-9]+/g, " ")
+            .trim()
+            .replaceAll(" ", separator),
+        ),
+      ),
+    ),
+});
+
+export const toTitleCase = defineOperation({
+  id: "to-title-case",
+  name: "To Title Case",
+  description: 'Capitalizes the first letter of every word and lowercases the others. e.g. "hello WORLD" becomes "Hello World".',
+  category: "Text",
+  output: "binary",
+  aliases: ["capitalize", "titlecase"],
+  args: {},
+  examples: [{ input: "hello WORLD, don't panic", output: "Hello World, Don't Panic" }],
+  run: (input) => mapText(input, (text) => text.replace(/[\p{L}\p{N}][\p{L}\p{N}\p{M}'’]*/gu, capitalize)),
+});
+
+export const toUpperCase = defineOperation({
+  id: "to-upper-case",
+  name: "To UPPER CASE",
+  description: 'Converts the text to uppercase. e.g. "héllo" becomes "HÉLLO".',
+  category: "Text",
+  output: "binary",
+  aliases: ["uppercase", "capitals"],
+  args: {},
+  examples: [{ input: "héllo world", output: "HÉLLO WORLD" }],
+  run: (input) => mapText(input, (text) => text.toUpperCase()),
+});
+
+export const toLowerCase = defineOperation({
+  id: "to-lower-case",
+  name: "To lower case",
+  description: 'Converts the text to lowercase. e.g. "HÉLLO" becomes "héllo".',
+  category: "Text",
+  output: "binary",
+  aliases: ["lowercase"],
+  args: {},
+  examples: [{ input: "HÉLLO World", output: "héllo world" }],
+  run: (input) => mapText(input, (text) => text.toLowerCase()),
+});

package/src/operations/text/count.ts

@@ -0,0 +1,61 @@
+import { defineOperation } from "../../operation.ts";
+import { splitLines } from "./lines.ts";
+
+const encodeNumber = (n: number) => new TextEncoder().encode(String(n));
+
+const UNITS = [
+  { value: "graphemes", label: "Characters as displayed (é and 👍🏽 count as 1)" },
+  { value: "codepoints", label: "Unicode code points" },
+  { value: "bytes", label: "Bytes" },
+] as const;
+
+export const countChars = defineOperation({
+  id: "count-chars",
+  name: "Count characters",
+  description: "Counts the characters of the input, line breaks included, like `wc -m`.",
+  category: "Text",
+  output: "text",
+  aliases: ["length", "wc -m", "char count"],
+  args: {
+    unit: { type: "select", name: "Unit", options: UNITS, default: "graphemes" },
+  },
+  examples: [
+    { input: "héllo 👍🏽", output: "7" },
+    { input: "héllo 👍🏽", args: { unit: "codepoints" }, output: "8" },
+    { input: "héllo 👍🏽", args: { unit: "bytes" }, output: "15" },
+  ],
+  run(input, { unit }) {
+    if (unit === "bytes") return encodeNumber(input.length);
+    const text = new TextDecoder().decode(input);
+    if (unit === "codepoints") return encodeNumber([...text].length);
+    return encodeNumber([...new Intl.Segmenter().segment(text)].length);
+  },
+});
+
+export const countLines = defineOperation({
+  id: "count-lines",
+  name: "Count lines",
+  description: "Counts the lines of the input. Unlike `wc -l`, a last line without a line break is counted.",
+  category: "Text",
+  output: "text",
+  aliases: ["wc -l", "line count"],
+  args: {},
+  examples: [
+    { input: "a\nb\nc", output: "3" },
+    { input: "a\nb\n", output: "2" },
+    { input: "", output: "0" },
+  ],
+  run: (input) => encodeNumber(splitLines(new TextDecoder().decode(input)).lines.length),
+});
+
+export const countWords = defineOperation({
+  id: "count-words",
+  name: "Count words",
+  description: "Counts the words of the input, separated by whitespace, like `wc -w`.",
+  category: "Text",
+  output: "text",
+  aliases: ["wc -w", "word count"],
+  args: {},
+  examples: [{ input: "  hello big\n world ", output: "3" }],
+  run: (input) => encodeNumber(new TextDecoder().decode(input).split(/\s+/).filter(Boolean).length),
+});

package/src/operations/text/line-operations.ts

@@ -0,0 +1,144 @@
+import { defineOperation } from "../../operation.ts";
+import { mapLines, mapText } from "./lines.ts";
+
+export const sortLines = defineOperation({
+  id: "sort-lines",
+  name: "Sort lines",
+  description: "Sorts the lines by Unicode code point, like `LC_ALL=C sort`, or in natural order.",
+  category: "Text",
+  output: "binary",
+  aliases: ["sort", "order"],
+  args: {
+    reverse: { type: "boolean", name: "Reverse", description: "Sort in descending order.", default: false },
+    ignoreCase: { type: "boolean", name: "Ignore case", default: false },
+    natural: {
+      type: "boolean",
+      name: "Natural order",
+      description: 'Compare numbers by value ("2" before "10") and letters alphabetically ("a" before "B").',
+      default: false,
+    },
+  },
+  examples: [
+    { input: "b\nB\na\n10\n2", output: "10\n2\nB\na\nb" },
+    { input: "b\nB\na\n10\n2", args: { natural: true, ignoreCase: true }, output: "2\n10\na\nb\nB" },
+    { input: "a\nc\nb", args: { reverse: true }, output: "c\nb\na" },
+  ],
+  run(input, { reverse, ignoreCase, natural }) {
+    const collator = new Intl.Collator("en", { numeric: true, sensitivity: ignoreCase ? "accent" : "variant" });
+    const key = (line: string) => (ignoreCase ? line.toLowerCase() : line);
+    const compare = natural ? collator.compare : (a: string, b: string) => (key(a) < key(b) ? -1 : key(a) > key(b) ? 1 : 0);
+    return mapText(input, (text) => mapLines(text, (lines) => lines.toSorted(reverse ? (a, b) => compare(b, a) : compare)));
+  },
+});
+
+/** Mulberry32, seeded with the FNV-1a hash of the seed: reproducible, not cryptographically secure. */
+function seededRandom(seed: string): () => number {
+  let state = 0x811c9dc5;
+  for (const byte of new TextEncoder().encode(seed)) state = Math.imul(state ^ byte, 0x01000193);
+  return () => {
+    state = (state + 0x6d2b79f5) | 0;
+    let t = Math.imul(state ^ (state >>> 15), 1 | state);
+    t = (t + Math.imul(t ^ (t >>> 7), 61 | t)) ^ t;
+    return ((t ^ (t >>> 14)) >>> 0) / 2 ** 32;
+  };
+}
+
+const secureRandom = () => crypto.getRandomValues(new Uint32Array(1))[0]! / 2 ** 32;
+
+export const shuffleLines = defineOperation({
+  id: "shuffle-lines",
+  name: "Shuffle lines",
+  description: "Puts the lines in a random order.",
+  category: "Text",
+  output: "binary",
+  aliases: ["shuf", "randomize"],
+  args: {
+    seed: {
+      type: "string",
+      name: "Seed",
+      description: "Gives the same order every time for the same seed and input. Leave empty for a random order.",
+      default: "",
+    },
+  },
+  examples: [{ input: "a\nb\nc\nd", args: { seed: "42" }, output: "c\na\nd\nb" }],
+  run(input, { seed }) {
+    const random = seed ? seededRandom(seed) : secureRandom;
+    return mapText(input, (text) =>
+      mapLines(text, (lines) => {
+        // Fisher-Yates.
+        const shuffled = [...lines];
+        for (let i = shuffled.length - 1; i > 0; i--) {
+          const j = Math.floor(random() * (i + 1));
+          [shuffled[i], shuffled[j]] = [shuffled[j]!, shuffled[i]!];
+        }
+        return shuffled;
+      }),
+    );
+  },
+});
+
+export const uniqueLines = defineOperation({
+  id: "unique-lines",
+  name: "Unique lines",
+  description: "Removes duplicate lines, keeping the first occurrence of each, even when duplicates are not adjacent.",
+  category: "Text",
+  output: "binary",
+  aliases: ["uniq", "dedupe", "remove duplicates"],
+  args: {
+    ignoreCase: { type: "boolean", name: "Ignore case", default: false },
+  },
+  examples: [
+    { input: "a\nb\na\nc\nb", output: "a\nb\nc" },
+    { input: "a\nA\nb", args: { ignoreCase: true }, output: "a\nb" },
+  ],
+  run(input, { ignoreCase }) {
+    return mapText(input, (text) =>
+      mapLines(text, (lines) => {
+        const seen = new Set<string>();
+        return lines.filter((line) => {
+          const key = ignoreCase ? line.toLowerCase() : line;
+          if (seen.has(key)) return false;
+          seen.add(key);
+          return true;
+        });
+      }),
+    );
+  },
+});
+
+export const reverseLines = defineOperation({
+  id: "reverse-lines",
+  name: "Reverse lines",
+  description: "Reverses the order of the lines, like `tac`.",
+  category: "Text",
+  output: "binary",
+  aliases: ["tac"],
+  args: {},
+  examples: [{ input: "a\nb\nc\n", output: "c\nb\na\n" }],
+  run: (input) => mapText(input, (text) => mapLines(text, (lines) => lines.toReversed())),
+});
+
+export const addLineNumbers = defineOperation({
+  id: "add-line-numbers",
+  name: "Add line numbers",
+  description: "Prefixes every line with its number, right-aligned, like `cat -n`.",
+  category: "Text",
+  output: "binary",
+  aliases: ["line numberer", "nl", "cat -n"],
+  args: {
+    start: { type: "number", name: "First number", default: 1 },
+    separator: { type: "string", name: "Separator", description: "Placed between the number and the line.", default: " " },
+  },
+  examples: [
+    { input: "a\nb", output: "1 a\n2 b" },
+    { input: "a\nb\nc", args: { start: 9, separator: ": " }, output: " 9: a\n10: b\n11: c" },
+  ],
+  run(input, { start, separator }) {
+    return mapText(input, (text) =>
+      mapLines(text, (lines) => {
+        const width = Math.max(String(start).length, String(start + lines.length - 1).length);
+        return lines.map((line, i) => String(start + i).padStart(width) + separator + line);
+      }),
+    );
+  },
+});

package/src/operations/text/lines.ts

@@ -0,0 +1,22 @@
+/**
+ * Splits text into lines. The line ending is CRLF if the text contains one, else LF. A final line
+ * ending does not start a new line: "a\nb\n" gives ["a", "b"], and "" gives no lines.
+ */
+export function splitLines(text: string): { lines: string[]; eol: string; trailing: boolean } {
+  const eol = text.includes("\r\n") ? "\r\n" : "\n";
+  const trailing = text.endsWith(eol);
+  const body = trailing ? text.slice(0, -eol.length) : text;
+  return { lines: text === "" ? [] : body.split(eol), eol, trailing };
+}
+
+/** Applies `fn` to the lines of `text`, keeping its line ending and final line ending. */
+export function mapLines(text: string, fn: (lines: string[]) => string[]): string {
+  const { lines, eol, trailing } = splitLines(text);
+  if (!lines.length) return text;
+  return fn(lines).join(eol) + (trailing ? eol : "");
+}
+
+/** Decodes the input as UTF-8, transforms it, and encodes the result back. */
+export function mapText(input: Uint8Array, fn: (text: string) => string): Uint8Array {
+  return new TextEncoder().encode(fn(new TextDecoder().decode(input)));
+}

package/src/operations/text/text-operations.ts

@@ -0,0 +1,85 @@
+import { defineOperation } from "../../operation.ts";
+import { mapText } from "./lines.ts";
+
+export const reverseText = defineOperation({
+  id: "reverse-text",
+  name: "Reverse text",
+  description: 'Reverses the order of the characters. Accented letters and emoji stay intact. e.g. "héllo" becomes "olléh".',
+  category: "Text",
+  output: "binary",
+  aliases: ["reverse string", "mirror"],
+  args: {},
+  examples: [
+    { input: "héllo", output: "olléh" },
+    { input: "a👍🏽b", output: "b👍🏽a" },
+  ],
+  run: (input) =>
+    mapText(input, (text) => {
+      const graphemes = [...new Intl.Segmenter().segment(text)].map((s) => s.segment);
+      return graphemes.reverse().join("");
+    }),
+});
+
+export const removeNewlines = defineOperation({
+  id: "remove-newlines",
+  name: "Remove newlines",
+  description: "Removes every line break (LF, CRLF and CR), or replaces it with the given text.",
+  category: "Text",
+  output: "binary",
+  aliases: ["join lines", "single line", "strip newlines"],
+  args: {
+    replacement: { type: "string", name: "Replacement", default: "" },
+  },
+  examples: [
+    { input: "a\nb\r\nc", output: "abc" },
+    { input: "a\nb\nc", args: { replacement: ", " }, output: "a, b, c" },
+  ],
+  run: (input, { replacement }) => mapText(input, (text) => text.replace(/\r\n|\r|\n/g, replacement)),
+});
+
+export const removeWhitespace = defineOperation({
+  id: "remove-whitespace",
+  name: "Remove whitespace",
+  description: "Removes all spaces, tabs, line breaks and other Unicode whitespace.",
+  category: "Text",
+  output: "binary",
+  aliases: ["remove spaces", "strip whitespace", "trim"],
+  args: {
+    keepNewlines: { type: "boolean", name: "Keep line breaks", default: false },
+  },
+  examples: [
+    { input: "a b\tc\nd", output: "abcd" },
+    { input: "a b\nc d", args: { keepNewlines: true }, output: "ab\ncd" },
+  ],
+  run: (input, { keepNewlines }) => mapText(input, (text) => text.replace(keepNewlines ? /[^\S\r\n]+/g : /\s+/g, "")),
+});
+
+const QUOTES = [
+  { value: "double", label: 'Double quotes (")' },
+  { value: "single", label: "Single quotes (')" },
+  { value: "both", label: "Both" },
+] as const;
+
+const QUOTE_PATTERNS: Record<(typeof QUOTES)[number]["value"], string> = { double: '"', single: "'", both: "\"'" };
+
+export const escapeQuotes = defineOperation({
+  id: "escape-quotes",
+  name: "Escape quotes",
+  description: 'Puts a backslash before quotes, and before backslashes so the result is unambiguous. e.g. say "hi" becomes say \\"hi\\".',
+  category: "Text",
+  output: "binary",
+  aliases: ["escape string", "addslashes"],
+  args: {
+    quotes: { type: "select", name: "Quotes", options: QUOTES, default: "double" },
+    escapeBackslashes: { type: "boolean", name: "Escape backslashes", default: true },
+  },
+  examples: [
+    { input: 'say "hi" \\o/', output: 'say \\"hi\\" \\\\o/' },
+    { input: `it's "ok"`, args: { quotes: "single" }, output: `it\\'s "ok"` },
+    { input: `'a' "b" \\`, args: { quotes: "both", escapeBackslashes: false }, output: `\\'a\\' \\"b\\" \\` },
+  ],
+  run(input, { quotes, escapeBackslashes }) {
+    const pattern = new RegExp(`[${QUOTE_PATTERNS[quotes]}${escapeBackslashes ? "\\\\" : ""}]`, "g");
+    return mapText(input, (text) => text.replace(pattern, "\\$&"));
+  },
+});

package/src/operations/url/url-decode.ts

@@ -0,0 +1,55 @@
+import { defineOperation } from "../../operation.ts";
+
+const PERCENT = 0x25;
+const PLUS = 0x2b;
+const SPACE = 0x20;
+
+function hexValue(byte: number | undefined): number {
+  if (byte === undefined) return -1;
+  if (byte >= 0x30 && byte <= 0x39) return byte - 0x30;
+  const lower = byte | 0x20;
+  if (lower >= 0x61 && lower <= 0x66) return lower - 0x61 + 10;
+  return -1;
+}
+
+export const urlDecode = defineOperation({
+  id: "url-decode",
+  name: "URL Decode",
+  description: "Decodes %XX sequences (percent-encoding) into bytes. Invalid sequences are left as is.",
+  category: "Encoding",
+  output: "binary",
+  aliases: ["percent decode", "urldecode"],
+  inverse: "url-encode",
+  infoUrl: "https://wikipedia.org/wiki/Percent-encoding",
+  args: {
+    plusAsSpace: {
+      type: "boolean",
+      name: 'Treat "+" as space',
+      description: "HTML form behavior (application/x-www-form-urlencoded).",
+      default: true,
+    },
+  },
+  examples: [
+    { input: "a%20b%26c%3D%C3%A9", output: "a b&c=é" },
+    { input: "a+b", output: "a b" },
+    { input: "a+b", args: { plusAsSpace: false }, output: "a+b" },
+  ],
+  run(input, { plusAsSpace }) {
+    const out = new Uint8Array(input.length);
+    let n = 0;
+    for (let i = 0; i < input.length; i++) {
+      const byte = input[i]!;
+      if (byte === PERCENT) {
+        const hi = hexValue(input[i + 1]);
+        const lo = hexValue(input[i + 2]);
+        if (hi >= 0 && lo >= 0) {
+          out[n++] = (hi << 4) | lo;
+          i += 2;
+          continue;
+        }
+      }
+      out[n++] = byte === PLUS && plusAsSpace ? SPACE : byte;
+    }
+    return out.slice(0, n);
+  },
+});

package/src/operations/url/url-encode.ts

@@ -0,0 +1,38 @@
+import { defineOperation } from "../../operation.ts";
+
+// RFC 3986 unreserved characters.
+const UNRESERVED = /[A-Za-z0-9\-_.~]/;
+// Characters also left untouched by `encodeURI`.
+const URI_SAFE = /[A-Za-z0-9\-_.~!*'();/?:@&=+$,#]/;
+
+export const urlEncode = defineOperation({
+  id: "url-encode",
+  name: "URL Encode",
+  description: 'Encodes bytes as %XX sequences (percent-encoding). e.g. "a b" becomes "a%20b".',
+  category: "Encoding",
+  output: "text",
+  aliases: ["percent encode", "urlencode"],
+  inverse: "url-decode",
+  infoUrl: "https://wikipedia.org/wiki/Percent-encoding",
+  args: {
+    encodeAll: {
+      type: "boolean",
+      name: "Encode all special chars",
+      description: "Also encode reserved characters such as / ? & = (like encodeURIComponent).",
+      default: false,
+    },
+  },
+  examples: [
+    { input: "a b&c=é", output: "a%20b&c=%C3%A9" },
+    { input: "a b&c=é", args: { encodeAll: true }, output: "a%20b%26c%3D%C3%A9" },
+  ],
+  run(input, { encodeAll }) {
+    const keep = encodeAll ? UNRESERVED : URI_SAFE;
+    let out = "";
+    for (const byte of input) {
+      const ch = String.fromCharCode(byte);
+      out += byte < 0x80 && keep.test(ch) ? ch : "%" + byte.toString(16).toUpperCase().padStart(2, "0");
+    }
+    return new TextEncoder().encode(out);
+  },
+});