@no-k/hermes 0.1.0

package/templates/data-structure/segment-tree/segment-tree.ts

@@ -0,0 +1,79 @@
+type SegmentTreeOptions<T> = {
+  identity: T;
+  combine: (left: T, right: T) => T;
+};
+
+export class SegmentTree<T> {
+  private tree: T[];
+  private length: number;
+  private identity: T;
+  private combine: (left: T, right: T) => T;
+
+  constructor(values: T[], options: SegmentTreeOptions<T>) {
+    this.length = values.length;
+    this.identity = options.identity;
+    this.combine = options.combine;
+    this.tree = Array(Math.max(1, this.length * 2)).fill(this.identity);
+
+    for (let index = 0; index < this.length; index += 1) {
+      this.tree[this.length + index] = values[index];
+    }
+
+    for (let index = this.length - 1; index > 0; index -= 1) {
+      this.tree[index] = this.combine(this.tree[index * 2], this.tree[index * 2 + 1]);
+    }
+  }
+
+  size() {
+    return this.length;
+  }
+
+  update(index: number, value: T) {
+    this.assertIndex(index);
+
+    let current = index + this.length;
+    this.tree[current] = value;
+
+    while (current > 1) {
+      current = Math.floor(current / 2);
+      this.tree[current] = this.combine(this.tree[current * 2], this.tree[current * 2 + 1]);
+    }
+  }
+
+  query(left: number, right: number): T {
+    if (left > right) {
+      return this.identity;
+    }
+
+    this.assertIndex(left);
+    this.assertIndex(right);
+
+    let start = left + this.length;
+    let end = right + this.length;
+    let leftResult = this.identity;
+    let rightResult = this.identity;
+
+    while (start <= end) {
+      if (start % 2 === 1) {
+        leftResult = this.combine(leftResult, this.tree[start]);
+        start += 1;
+      }
+
+      if (end % 2 === 0) {
+        rightResult = this.combine(this.tree[end], rightResult);
+        end -= 1;
+      }
+
+      start = Math.floor(start / 2);
+      end = Math.floor(end / 2);
+    }
+
+    return this.combine(leftResult, rightResult);
+  }
+
+  private assertIndex(index: number) {
+    if (!Number.isInteger(index) || index < 0 || index >= this.length) {
+      throw new RangeError("index is out of range");
+    }
+  }
+}

package/templates/data-structure/trie/index.ts

@@ -0,0 +1 @@
+export * from "./trie";

package/templates/data-structure/trie/trie.ts

@@ -0,0 +1,104 @@
+class TrieNode {
+  children = new Map<string, TrieNode>();
+  isWord = false;
+}
+
+export class Trie {
+  private root = new TrieNode();
+  private words = 0;
+
+  size() {
+    return this.words;
+  }
+
+  insert(word: string) {
+    let node = this.root;
+
+    for (const char of word) {
+      const next = node.children.get(char) ?? new TrieNode();
+      node.children.set(char, next);
+      node = next;
+    }
+
+    if (!node.isWord) {
+      this.words += 1;
+    }
+
+    node.isWord = true;
+  }
+
+  has(word: string) {
+    return this.findNode(word)?.isWord ?? false;
+  }
+
+  startsWith(prefix: string) {
+    return this.findNode(prefix) !== null;
+  }
+
+  delete(word: string) {
+    if (!this.has(word)) {
+      return false;
+    }
+
+    const remove = (node: TrieNode, index: number): boolean => {
+      if (index === word.length) {
+        node.isWord = false;
+        this.words -= 1;
+
+        return node.children.size === 0;
+      }
+
+      const char = word[index];
+      const next = node.children.get(char) as TrieNode;
+      const shouldDeleteChild = remove(next, index + 1);
+
+      if (shouldDeleteChild) {
+        node.children.delete(char);
+      }
+
+      return !node.isWord && node.children.size === 0;
+    };
+
+    remove(this.root, 0);
+
+    return true;
+  }
+
+  collect(prefix = "") {
+    const node = this.findNode(prefix);
+    if (!node) {
+      return [];
+    }
+
+    const result: string[] = [];
+
+    const visit = (current: TrieNode, word: string) => {
+      if (current.isWord) {
+        result.push(word);
+      }
+
+      for (const [char, next] of current.children) {
+        visit(next, word + char);
+      }
+    };
+
+    visit(node, prefix);
+
+    return result;
+  }
+
+  private findNode(value: string): TrieNode | null {
+    let node = this.root;
+
+    for (const char of value) {
+      const next = node.children.get(char);
+      if (!next) {
+        return null;
+      }
+
+      node = next;
+    }
+
+    return node;
+  }
+}

package/templates/data-structure/union-find/index.ts

@@ -0,0 +1 @@
+export * from "./union-find";

package/templates/data-structure/union-find/union-find.ts

@@ -0,0 +1,79 @@
+export class UnionFind<T> {
+  private parents = new Map<T, T>();
+  private sizes = new Map<T, number>();
+  private components = 0;
+
+  constructor(values: Iterable<T> = []) {
+    for (const value of values) {
+      this.add(value);
+    }
+  }
+
+  add(value: T) {
+    if (this.parents.has(value)) {
+      return;
+    }
+
+    this.parents.set(value, value);
+    this.sizes.set(value, 1);
+    this.components += 1;
+  }
+
+  find(value: T): T {
+    this.add(value);
+
+    const parent = this.parents.get(value) as T;
+    if (parent === value) {
+      return value;
+    }
+
+    const root = this.find(parent);
+    this.parents.set(value, root);
+
+    return root;
+  }
+
+  union(a: T, b: T): boolean {
+    let aRoot = this.find(a);
+    let bRoot = this.find(b);
+
+    if (aRoot === bRoot) {
+      return false;
+    }
+
+    if ((this.sizes.get(aRoot) as number) < (this.sizes.get(bRoot) as number)) {
+      [aRoot, bRoot] = [bRoot, aRoot];
+    }
+
+    this.parents.set(bRoot, aRoot);
+    this.sizes.set(aRoot, (this.sizes.get(aRoot) as number) + (this.sizes.get(bRoot) as number));
+    this.components -= 1;
+
+    return true;
+  }
+
+  connected(a: T, b: T) {
+    return this.find(a) === this.find(b);
+  }
+
+  sizeOf(value: T) {
+    return this.sizes.get(this.find(value)) as number;
+  }
+
+  count() {
+    return this.components;
+  }
+
+  groups() {
+    const groups = new Map<T, T[]>();
+
+    for (const value of this.parents.keys()) {
+      const root = this.find(value);
+      const values = groups.get(root) ?? [];
+      values.push(value);
+      groups.set(root, values);
+    }
+
+    return [...groups.values()];
+  }
+}

package/templates/dom/attribute/attribute.ts

@@ -0,0 +1,24 @@
+export type AttributeValue = string | number | boolean | null | undefined;
+
+export const getAttributeValue = (element: Element, name: string): string | undefined => {
+  return element.getAttribute(name) ?? undefined;
+};
+
+export const setAttributeValue = <T extends Element>(element: T, name: string, value: AttributeValue): T => {
+  if (value === null || value === undefined) {
+    element.removeAttribute(name);
+    return element;
+  }
+
+  element.setAttribute(name, String(value));
+
+  return element;
+};
+
+export const setAttributes = <T extends Element>(element: T, attributes: Record<string, AttributeValue>): T => {
+  for (const [name, value] of Object.entries(attributes)) {
+    setAttributeValue(element, name, value);
+  }
+
+  return element;
+};

package/templates/dom/attribute/index.ts

@@ -0,0 +1 @@
+export * from "./attribute";

package/templates/dom/class-name/class-name.ts

@@ -0,0 +1,48 @@
+type ClassNameInput = string | readonly string[];
+
+const normalizeClassNames = (classNames: ClassNameInput): string[] => {
+  const values =
+    typeof classNames === "string" ? classNames.split(/\s+/) : classNames.flatMap((name) => name.split(/\s+/));
+
+  return values.map((name) => name.trim()).filter((name) => name.length > 0);
+};
+
+export const hasClass = (element: Element, className: string): boolean => {
+  const [normalizedClassName, extraClassName] = normalizeClassNames(className);
+
+  if (normalizedClassName === undefined || extraClassName !== undefined) {
+    return false;
+  }
+
+  return element.classList.contains(normalizedClassName);
+};
+
+export const addClass = <T extends Element>(element: T, classNames: ClassNameInput): T => {
+  const normalizedClassNames = normalizeClassNames(classNames);
+
+  if (normalizedClassNames.length > 0) {
+    element.classList.add(...normalizedClassNames);
+  }
+
+  return element;
+};
+
+export const removeClass = <T extends Element>(element: T, classNames: ClassNameInput): T => {
+  const normalizedClassNames = normalizeClassNames(classNames);
+
+  if (normalizedClassNames.length > 0) {
+    element.classList.remove(...normalizedClassNames);
+  }
+
+  return element;
+};
+
+export const toggleClass = (element: Element, className: string, force?: boolean): boolean => {
+  const [normalizedClassName, extraClassName] = normalizeClassNames(className);
+
+  if (normalizedClassName === undefined || extraClassName !== undefined) {
+    return false;
+  }
+
+  return element.classList.toggle(normalizedClassName, force);
+};

package/templates/dom/class-name/index.ts

@@ -0,0 +1 @@
+export * from "./class-name";

package/templates/dom/is-element/index.ts

@@ -0,0 +1 @@
+export * from "./is-element";

package/templates/dom/is-element/is-element.ts

@@ -0,0 +1,20 @@
+export const isElement = (value: unknown, tagName?: string): value is Element => {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+
+  const candidate = value as {
+    nodeName?: unknown;
+    nodeType?: unknown;
+  };
+
+  if (candidate.nodeType !== 1 || typeof candidate.nodeName !== "string") {
+    return false;
+  }
+
+  if (tagName === undefined) {
+    return true;
+  }
+
+  return candidate.nodeName.toLowerCase() === tagName.trim().toLowerCase();
+};

package/templates/dom/query/index.ts

@@ -0,0 +1 @@
+export * from "./query";

package/templates/dom/query/query.ts

@@ -0,0 +1,7 @@
+export const queryElement = <T extends Element = Element>(root: ParentNode, selector: string): T | undefined => {
+  return root.querySelector<T>(selector) ?? undefined;
+};
+
+export const queryElements = <T extends Element = Element>(root: ParentNode, selector: string): T[] => {
+  return Array.from(root.querySelectorAll<T>(selector));
+};

package/templates/http/content-type/content-type.ts

@@ -0,0 +1,130 @@
+export const HTTP_CONTENT_TYPE = {
+  APPLICATION_FORM_URLENCODED: "application/x-www-form-urlencoded",
+  APPLICATION_JAVASCRIPT: "application/javascript",
+  APPLICATION_JSON: "application/json",
+  APPLICATION_OCTET_STREAM: "application/octet-stream",
+  APPLICATION_PDF: "application/pdf",
+  APPLICATION_XML: "application/xml",
+  IMAGE_SVG_XML: "image/svg+xml",
+  MULTIPART_FORM_DATA: "multipart/form-data",
+  TEXT_CSS: "text/css",
+  TEXT_CSV: "text/csv",
+  TEXT_HTML: "text/html",
+  TEXT_PLAIN: "text/plain",
+  TEXT_XML: "text/xml",
+} as const;
+
+export type HttpContentType = (typeof HTTP_CONTENT_TYPE)[keyof typeof HTTP_CONTENT_TYPE];
+
+export type ParsedContentType = {
+  type: string;
+  subtype: string;
+  mimeType: string;
+  parameters: Record<string, string>;
+};
+
+const HTTP_TOKEN_PATTERN = /^[!#$%&'*+\-.^_`|~0-9A-Za-z]+$/;
+
+const splitContentTypeSegments = (contentType: string): string[] => {
+  const segments: string[] = [];
+  let segment = "";
+  let isQuoted = false;
+  let isEscaped = false;
+
+  for (const char of contentType) {
+    if (isEscaped) {
+      segment += char;
+      isEscaped = false;
+      continue;
+    }
+
+    if (char === "\\" && isQuoted) {
+      segment += char;
+      isEscaped = true;
+      continue;
+    }
+
+    if (char === '"') {
+      segment += char;
+      isQuoted = !isQuoted;
+      continue;
+    }
+
+    if (char === ";" && !isQuoted) {
+      segments.push(segment.trim());
+      segment = "";
+      continue;
+    }
+
+    segment += char;
+  }
+
+  segments.push(segment.trim());
+
+  return segments;
+};
+
+const unquoteParameterValue = (value: string): string => {
+  const trimmedValue = value.trim();
+
+  if (trimmedValue.length < 2 || !trimmedValue.startsWith('"') || !trimmedValue.endsWith('"')) {
+    return trimmedValue;
+  }
+
+  return trimmedValue.slice(1, -1).replace(/\\(["\\])/g, "$1");
+};
+
+export const parseContentType = (contentType: string): ParsedContentType | undefined => {
+  const [rawMimeType, ...rawParameters] = splitContentTypeSegments(contentType);
+
+  if (rawMimeType === undefined) {
+    return undefined;
+  }
+
+  const mimeType = rawMimeType.trim().toLowerCase();
+  const mimeTypeSegments = mimeType.split("/");
+
+  if (mimeTypeSegments.length !== 2) {
+    return undefined;
+  }
+
+  const [type, subtype] = mimeTypeSegments;
+
+  if (!HTTP_TOKEN_PATTERN.test(type) || !HTTP_TOKEN_PATTERN.test(subtype)) {
+    return undefined;
+  }
+
+  const parameters: Record<string, string> = {};
+
+  for (const rawParameter of rawParameters) {
+    const separatorIndex = rawParameter.indexOf("=");
+
+    if (separatorIndex === -1) {
+      continue;
+    }
+
+    const parameterName = rawParameter.slice(0, separatorIndex).trim().toLowerCase();
+
+    if (!HTTP_TOKEN_PATTERN.test(parameterName)) {
+      continue;
+    }
+
+    parameters[parameterName] = unquoteParameterValue(rawParameter.slice(separatorIndex + 1));
+  }
+
+  return {
+    type,
+    subtype,
+    mimeType: `${type}/${subtype}`,
+    parameters,
+  };
+};
+
+export const isJsonContentType = (contentType: string): boolean => {
+  const parsedContentType = parseContentType(contentType);
+
+  return (
+    parsedContentType !== undefined &&
+    (parsedContentType.mimeType === HTTP_CONTENT_TYPE.APPLICATION_JSON || parsedContentType.subtype.endsWith("+json"))
+  );
+};

package/templates/http/content-type/index.ts

@@ -0,0 +1 @@
+export * from "./content-type";

package/templates/http/header/header.ts

@@ -0,0 +1,56 @@
+export const HTTP_HEADER = {
+  ACCEPT: "Accept",
+  ACCEPT_ENCODING: "Accept-Encoding",
+  ACCEPT_LANGUAGE: "Accept-Language",
+  ACCESS_CONTROL_ALLOW_ORIGIN: "Access-Control-Allow-Origin",
+  AUTHORIZATION: "Authorization",
+  CACHE_CONTROL: "Cache-Control",
+  CONTENT_ENCODING: "Content-Encoding",
+  CONTENT_LENGTH: "Content-Length",
+  CONTENT_TYPE: "Content-Type",
+  COOKIE: "Cookie",
+  ETAG: "ETag",
+  HOST: "Host",
+  IF_NONE_MATCH: "If-None-Match",
+  LOCATION: "Location",
+  ORIGIN: "Origin",
+  REFERER: "Referer",
+  RETRY_AFTER: "Retry-After",
+  SET_COOKIE: "Set-Cookie",
+  USER_AGENT: "User-Agent",
+  WWW_AUTHENTICATE: "WWW-Authenticate",
+  X_REQUEST_ID: "X-Request-Id",
+  X_REQUESTED_WITH: "X-Requested-With",
+} as const;
+
+export type HttpHeader = (typeof HTTP_HEADER)[keyof typeof HTTP_HEADER];
+
+const HTTP_HEADER_NAME_PATTERN = /^[!#$%&'*+\-.^_`|~0-9A-Za-z]+$/;
+const CANONICAL_HTTP_HEADER_BY_LOWERCASE = new Map(
+  Object.values(HTTP_HEADER).map((name) => [name.toLowerCase(), name]),
+);
+
+export const isHttpHeaderName = (name: string): boolean => {
+  return HTTP_HEADER_NAME_PATTERN.test(name);
+};
+
+export const normalizeHeaderName = (name: string): string => {
+  const trimmedName = name.trim();
+
+  if (trimmedName.length === 0) {
+    return "";
+  }
+
+  const normalizedName = trimmedName
+    .split("-")
+    .map((segment) => {
+      if (segment.length === 0) {
+        return segment;
+      }
+
+      return `${segment.charAt(0).toUpperCase()}${segment.slice(1).toLowerCase()}`;
+    })
+    .join("-");
+
+  return CANONICAL_HTTP_HEADER_BY_LOWERCASE.get(normalizedName.toLowerCase()) ?? normalizedName;
+};

package/templates/http/header/index.ts

@@ -0,0 +1 @@
+export * from "./header";

package/templates/http/method/index.ts

@@ -0,0 +1 @@
+export * from "./method";

package/templates/http/method/method.ts

@@ -0,0 +1,25 @@
+export const HTTP_METHOD = {
+  CONNECT: "CONNECT",
+  DELETE: "DELETE",
+  GET: "GET",
+  HEAD: "HEAD",
+  OPTIONS: "OPTIONS",
+  PATCH: "PATCH",
+  POST: "POST",
+  PUT: "PUT",
+  TRACE: "TRACE",
+} as const;
+
+export type HttpMethod = (typeof HTTP_METHOD)[keyof typeof HTTP_METHOD];
+
+const HTTP_METHOD_SET = new Set<string>(Object.values(HTTP_METHOD));
+
+export const isHttpMethod = (method: string): method is HttpMethod => {
+  return HTTP_METHOD_SET.has(method);
+};
+
+export const normalizeHttpMethod = (method: string): HttpMethod | undefined => {
+  const normalizedMethod = method.trim().toUpperCase();
+
+  return isHttpMethod(normalizedMethod) ? normalizedMethod : undefined;
+};

package/templates/http/status/index.ts

@@ -0,0 +1 @@
+export * from "./status";