@seriousme/opifex 1.1.0

package/trie/trie.ts

@@ -0,0 +1,106 @@
+type Parts = string[];
+
+export class Trie<T> {
+  #value: Array<T>;
+  #children: Map<string, Trie<T>>;
+  private separator = "/";
+  private wildcardOne = "+";
+  private wildcardSubtree = "#";
+  private reservedPrefix = "$";
+  private looseCompare: boolean;
+
+  constructor(looseCompare = false) {
+    this.#value = [];
+    this.#children = new Map();
+    this.looseCompare = looseCompare;
+  }
+
+  matchChild(child: string, parts: Parts): Array<T> {
+    const childNode = this.#children.get(child);
+    return childNode ? childNode._match(parts) : [];
+  }
+
+  match(key: string) {
+    const parts = key.split(this.separator);
+    // toplevel wildcards are not allowed to match toplevel reserved topics
+    if (parts.length > 0 && parts[0].charAt(0) === this.reservedPrefix) {
+      return this._matchPrefix(parts);
+    }
+    return this._match(parts);
+  }
+
+  private _matchPrefix(parts: Parts): Array<T> {
+    if (parts.length === 0) {
+      return this.#value ? this.#value : [];
+    }
+    const [first, ...rest] = parts;
+    return this.matchChild(first, rest);
+  }
+
+  private _match(parts: Parts): Array<T> {
+    if (parts.length === 0) {
+      return this.#value ? this.#value : [];
+    }
+    const [first, ...rest] = parts;
+    const exact = this.matchChild(first, rest);
+    const single = this.matchChild(this.wildcardOne, rest);
+    const subtree = this.matchChild(this.wildcardSubtree, []);
+    const results = exact.concat(single, subtree);
+    return results;
+  }
+
+  add(key: string, value: T) {
+    return this._add(key.split(this.separator), value);
+  }
+
+  private _add(parts: Parts, value: T) {
+    if (parts.length === 0) {
+      this.#value = this.#value.concat(value);
+      return;
+    }
+    const [first, ...rest] = parts;
+    const child = this.#children.get(first);
+    if (child instanceof Trie) {
+      child._add(rest, value);
+    } else {
+      const node = new Trie<T>(this.looseCompare);
+      this.#children.set(first, node);
+      node._add(rest, value);
+    }
+    return;
+  }
+
+  remove(key: string, value: T) {
+    return this._remove(key.split(this.separator), value);
+  }
+
+  private _remove(parts: Parts, value: T): void {
+    if (parts.length === 0) {
+      const arr = this.#value || [];
+      this.#value = arr.filter(this.filter(value));
+      return;
+    }
+    const [first, ...rest] = parts;
+    const node = this.#children.get(first);
+    if (node) {
+      node._remove(rest, value);
+      if (node.#value.length === 0 && this.#children.size === 0) {
+        this.#children.delete(first);
+      }
+    }
+  }
+
+  private filter(value: T): (value: T, index: number, array: T[]) => boolean {
+    if (this.looseCompare && typeof value === "object") {
+      return (item) => {
+        for (const key in value) {
+          if (value[key] !== item[key]) {
+            return true;
+          }
+        }
+        return false;
+      };
+    }
+    return (item) => item !== value;
+  }
+}

package/utils/args.ts

@@ -0,0 +1,86 @@
+// deno-lint-ignore no-explicit-any
+export type Args = Record<string, any>;
+export type ArgsValue = string | number | boolean;
+
+type ArgOpts = {
+  string?: string[];
+  boolean?: string[];
+  alias?: Record<string, string>;
+  default?: Args;
+};
+
+function formatValue(
+  key: string,
+  value: ArgsValue,
+  boolean: string[],
+  string: string[],
+): string | number | boolean {
+  if (key === "__proto__" || key === "constructor") {
+    throw new Error(`Invalid argument: ${key}`);
+  }
+
+  if (boolean.includes(key)) {
+    if (value !== "false") {
+      return true;
+    }
+    return false;
+  }
+  if (!string.includes(key)) {
+    const num = Number(value);
+    if (!Number.isNaN(num)) {
+      return num;
+    }
+  }
+  return value;
+}
+
+function parseKeyValue(
+  arg: string,
+  alias: Record<string, string>,
+): [string, ArgsValue] {
+  if (arg.startsWith("--no-")) {
+    const key = arg.slice(5);
+    return [key, false];
+  }
+  if (arg.startsWith("--")) {
+    const [key, value] = arg.slice(2).split("=", 2);
+    return [key, value];
+  }
+  if (arg.startsWith("-")) {
+    const [flag, value] = arg.slice(1).split("=", 2);
+    const key = alias[flag] || flag;
+    return [key, value];
+  }
+  return ["_", arg];
+}
+
+export function parseArgs(args: string[], opts: ArgOpts = {}): Args {
+  const { alias = {}, boolean = [], string = [], default: defaults = {} } =
+    opts;
+  const result = { ...defaults };
+  result["_"] = [];
+
+  for (let i = 0; i < args.length; i++) {
+    const [key, value] = parseKeyValue(args[i], alias);
+    if (key === "_") {
+      result["_"].push(formatValue(key, value, boolean, string));
+      continue;
+    }
+    if (value === undefined) {
+      const nextArg = args[i + 1];
+      if (
+        nextArg !== undefined &&
+        !nextArg.startsWith("-") &&
+        !boolean.includes(key)
+      ) {
+        result[key] = formatValue(key, nextArg, boolean, string);
+        i++;
+      } else {
+        result[key] = formatValue(key, value, boolean, string);
+      }
+      continue;
+    }
+    result[key] = formatValue(key, value, boolean, string);
+  }
+  return result;
+}

package/utils/assert.ts

@@ -0,0 +1,31 @@
+export class AssertionError extends Error {
+  /** Constructs a new instance. */
+  constructor(message: string) {
+    super(message);
+    this.name = "AssertionError";
+  }
+}
+
+export function assert(expr: unknown, msg = ""): asserts expr {
+  if (!expr) {
+    throw new AssertionError(msg);
+  }
+}
+
+/** An array-like object (`Array`, `Uint8Array`, `NodeList`, etc.) that is not a string */
+export type ArrayLikeArg<T> = ArrayLike<T> & object;
+
+export function assertArrayIncludes<T>(
+  actual: ArrayLikeArg<T>,
+  expected: ArrayLikeArg<T>,
+  msg?: string,
+) {
+  const actualArr = Array.from(actual);
+  const expectedArr = Array.from(expected);
+  for (const item of expectedArr) {
+    assert(
+      actualArr.includes(item),
+      msg + `\nExpected: ${expectedArr}\nActual: ${actualArr}`,
+    );
+  }
+}

package/utils/asyncQueue.ts

@@ -0,0 +1,63 @@
+import { nextTick } from "./nextTick.ts";
+
+export class AsyncQueue<T> {
+  private queue: T[] = [];
+  private maxQueueLength = Infinity;
+  private nextResolve = (_value: T) => {};
+  private nextReject = (_reason?: string) => {};
+  private done = false;
+  private hasNext = false;
+
+  constructor(maxQueueLength?: number) {
+    if (maxQueueLength) {
+      this.maxQueueLength = maxQueueLength;
+    }
+  }
+
+  async next(): Promise<T> {
+    await nextTick();
+    if (this.done && this.queue.length === 0) {
+      return Promise.reject("Closed");
+    }
+    return new Promise((resolve, reject) => {
+      if (this.queue.length > 0) {
+        const item = this.queue.shift();
+        if (item) {
+          return resolve(item);
+        }
+      }
+      this.nextResolve = resolve;
+      this.nextReject = reject;
+      this.hasNext = true;
+    });
+  }
+
+  close(reason = "closed"): void {
+    this.done = true;
+    if (this.hasNext) {
+      this.nextReject(reason);
+    }
+  }
+
+  async *[Symbol.asyncIterator](): AsyncGenerator<Awaited<T>, void, unknown> {
+    while (true) {
+      yield this.next();
+    }
+  }
+
+  push(item: T) {
+    if (this.hasNext) {
+      this.nextResolve(item);
+      this.hasNext = false;
+      return;
+    }
+    if (this.queue.length > this.maxQueueLength) {
+      this.queue.shift();
+    }
+    this.queue.push(item);
+  }
+
+  get isDone(): boolean {
+    return this.done;
+  }
+}

package/utils/deferred.ts

@@ -0,0 +1,12 @@
+export class Deferred<T> {
+  promise: Promise<T>;
+  resolve!: (val: T) => void;
+  reject!: (err: Error) => void;
+
+  constructor() {
+    this.promise = new Promise((resolve, reject) => {
+      this.resolve = resolve;
+      this.reject = reject;
+    });
+  }
+}

package/utils/logger.ts

@@ -0,0 +1,35 @@
+export const LogLevel = {
+  error: 0,
+  warn: 1,
+  info: 2,
+  verbose: 3,
+  debug: 4,
+} as const;
+
+export type TLogLevel = typeof LogLevel[keyof typeof LogLevel];
+
+export class Logger {
+  private defaultError = console.error;
+  private defaultWarn = console.warn;
+  private defaultInfo = console.info;
+  private defaultVerbose = console.log;
+  private defaultDebug = console.log;
+  // deno-lint-ignore no-explicit-any
+  private noop = (..._data: any[]) => {};
+  error = this.defaultError;
+  warn = this.defaultWarn;
+  info = this.defaultInfo;
+  verbose = this.noop;
+  debug = this.noop;
+
+  constructor() {}
+
+  level(logLevel: TLogLevel) {
+    this.warn = logLevel > 0 ? this.defaultWarn : this.noop;
+    this.info = logLevel > 1 ? this.defaultInfo : this.noop;
+    this.verbose = logLevel > 2 ? this.defaultVerbose : this.noop;
+    this.debug = logLevel > 3 ? this.defaultDebug : this.noop;
+  }
+}
+
+export const logger: Logger = new Logger();

package/utils/mod.ts

@@ -0,0 +1,7 @@
+export { assert } from "./assert.ts";
+export { Deferred } from "./deferred.ts";
+export { Logger, logger, LogLevel } from "./logger.ts";
+export { AsyncQueue } from "./asyncQueue.ts";
+export { nextTick } from "./nextTick.ts";
+export { parseArgs } from "./args.ts";
+export { getArgs } from "./platform.ts";

package/utils/nextTick.ts

@@ -0,0 +1,3 @@
+export function nextTick(): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, 0));
+}

package/utils/platform.ts

@@ -0,0 +1,4 @@
+import { argv } from "node:process";
+export function getArgs() {
+  return argv.slice(2);
+}