typia 13.1.0 → 13.1.19

package/src/internal/_isTypeInt64Bigint.ts

@@ -0,0 +1,12 @@
+export const _isTypeInt64Bigint = (value: bigint): boolean =>
+  MINIMUM <= value && value <= MAXIMUM;
+
+// Unlike the `number` path, a `bigint` represents both bounds exactly, so this
+// is the true inclusive int64 range rather than an exclusive approximation.
+//
+// The arguments must stay strings. `BigInt(9223372036854775807)` rounds its
+// `number` literal to `2 ** 63` before `BigInt` ever sees it, which is the
+// defect this helper exists to close; `BigInt("9223372036854775807")` parses
+// the digits directly and is exact.
+const MINIMUM = -BigInt("9223372036854775808");
+const MAXIMUM = BigInt("9223372036854775807");

package/src/internal/_isTypeUint64.ts

@@ -1,5 +1,6 @@
 export const _isTypeUint64 = (value: number): boolean =>
   Math.floor(value) === value && MINIMUM <= value && value <= MAXIMUM;
 
+// The maximum is `2 ** 64 - 1`, the uint64 upper bound.
 const MINIMUM = 0;
 const MAXIMUM = 2 ** 64 - 1;

package/src/internal/_isTypeUint64Bigint.ts

@@ -0,0 +1,7 @@
+export const _isTypeUint64Bigint = (value: bigint): boolean =>
+  MINIMUM <= value && value <= MAXIMUM;
+
+// See `_isTypeInt64Bigint`: the bound is exact only because the argument is a
+// string, and `bigint` can represent the true inclusive maximum.
+const MINIMUM = BigInt(0);
+const MAXIMUM = BigInt("18446744073709551615");

package/src/internal/_isUniqueItems.ts

@@ -1,12 +1,4 @@
 export const _isUniqueItems = (elements: any[]): boolean => {
-  // EMPTY OR ONLY ONE
-  if (elements.length < 2) return true;
-
-  // SHALLOW COMPARISON
-  if (["boolean", "bigint", "number", "string"].includes(typeof elements[0]))
-    return new Set(elements).size === elements.length;
-
-  // DEEP COMPARISON
   for (let i = 0; i < elements.length; i++)
     for (let j = i + 1; j < elements.length; j++)
       if (equals(new WeakMap())(elements[i], elements[j])) return false;
@@ -15,145 +7,155 @@ export const _isUniqueItems = (elements: any[]): boolean => {
 
 const equals = (visited: WeakMap<object, WeakMap<object, boolean>>) => {
   const next = (a: any, b: any): boolean => {
-    // SHALLOW EQUAL
     if (a === b) return true;
-    else if (typeof a !== typeof b || typeof a !== "object") return false;
-    // COMPARE CONTAINERS
-    else if (Array.isArray(a))
-      return Array.isArray(b) && a.map((x, i) => next(x, b[i])).every((x) => x);
-    else if (a instanceof Set)
+    if (
+      a === null ||
+      b === null ||
+      typeof a !== "object" ||
+      typeof b !== "object"
+    )
+      return false;
+
+    const previous: boolean | undefined = visited.get(a)?.get(b);
+    if (previous !== undefined) return previous;
+    const pairs: WeakMap<object, boolean> =
+      visited.get(a) ?? new WeakMap<object, boolean>();
+    visited.set(a, pairs);
+    pairs.set(b, true);
+
+    const result: boolean = compare(a, b);
+    pairs.set(b, result);
+    return result;
+  };
+
+  const compare = (a: object, b: object): boolean => {
+    if (Array.isArray(a)) {
+      if (!Array.isArray(b) || a.length !== b.length) return false;
+      for (let i = 0; i < a.length; i++) {
+        const aHas: boolean = Object.hasOwn(a, i);
+        if (aHas !== Object.hasOwn(b, i) || (aHas && !next(a[i], b[i])))
+          return false;
+      }
+      return true;
+    }
+    if (Array.isArray(b)) return false;
+
+    if (a instanceof Set) {
+      if (!(b instanceof Set) || a.size !== b.size) return false;
+      const unmatched: any[] = [...b];
+      for (const value of a) {
+        const index: number = unmatched.findIndex((candidate) =>
+          next(value, candidate),
+        );
+        if (index === -1) return false;
+        unmatched.splice(index, 1);
+      }
+      return true;
+    }
+    if (a instanceof Map) {
+      if (!(b instanceof Map) || a.size !== b.size) return false;
+      const unmatched: [any, any][] = [...b];
+      for (const [key, value] of a) {
+        const index: number = unmatched.findIndex(
+          ([candidateKey, candidateValue]) =>
+            next(key, candidateKey) && next(value, candidateValue),
+        );
+        if (index === -1) return false;
+        unmatched.splice(index, 1);
+      }
+      return true;
+    }
+
+    if (a instanceof Boolean)
+      return b instanceof Boolean && a.valueOf() === b.valueOf();
+    if (Object.prototype.toString.call(a) === "[object BigInt]")
       return (
-        b instanceof Set && a.size === b.size && [...a].every((x) => b.has(x))
+        Object.prototype.toString.call(b) === "[object BigInt]" &&
+        a.valueOf() === b.valueOf()
       );
-    else if (a instanceof Map)
+    if (Object.prototype.toString.call(a) === "[object Symbol]")
       return (
-        b instanceof Map &&
-        a.size === b.size &&
-        [...a].every(([k, v]) => b.has(k) && next(v, b.get(k)))
+        Object.prototype.toString.call(b) === "[object Symbol]" &&
+        a.valueOf() === b.valueOf()
       );
-    // ATOMIC CLASSES
-    else if (a instanceof Boolean)
-      return b instanceof Boolean
-        ? a.valueOf() === b.valueOf()
-        : a.valueOf() === b;
-    else if (a instanceof BigInt)
-      return b instanceof BigInt ? a === b : a === BigInt(b);
-    else if (a instanceof Number)
-      return b instanceof Number
-        ? a.valueOf() === b.valueOf()
-        : a.valueOf() === b;
-    else if (a instanceof String)
-      return b instanceof String
-        ? a.valueOf() === b.valueOf()
-        : a.valueOf() === b;
-    else if (a instanceof Date)
+    if (a instanceof Number)
+      return b instanceof Number && a.valueOf() === b.valueOf();
+    if (a instanceof String)
+      return b instanceof String && a.valueOf() === b.valueOf();
+    if (a instanceof Date)
       return b instanceof Date && a.getTime() === b.getTime();
-    // BINARY DATA
-    else if (a instanceof Uint8Array)
+    if (a instanceof RegExp)
       return (
-        b instanceof Uint8Array &&
-        a.length === b.length &&
-        a.every((x, i) => x === b[i])
+        b instanceof RegExp && a.source === b.source && a.flags === b.flags
       );
-    else if (a instanceof Uint8ClampedArray)
-      return (
-        b instanceof Uint8ClampedArray &&
-        a.length === b.length &&
-        a.every((x, i) => x === b[i])
-      );
-    else if (a instanceof Uint16Array)
-      return (
-        b instanceof Uint16Array &&
-        a.length === b.length &&
-        a.every((x, i) => x === b[i])
-      );
-    else if (a instanceof Uint32Array)
-      return (
-        b instanceof Uint32Array &&
-        a.length === b.length &&
-        a.every((x, i) => x === b[i])
-      );
-    else if (a instanceof BigUint64Array)
-      return (
-        b instanceof BigUint64Array &&
-        a.length === b.length &&
-        a.every((x, i) => x === b[i])
-      );
-    else if (a instanceof Int8Array)
-      return (
-        b instanceof Int8Array &&
-        a.length === b.length &&
-        a.every((x, i) => x === b[i])
-      );
-    else if (a instanceof Int16Array)
-      return (
-        b instanceof Int16Array &&
-        a.length === b.length &&
-        a.every((x, i) => x === b[i])
-      );
-    else if (a instanceof Int32Array)
-      return (
-        b instanceof Int32Array &&
-        a.length === b.length &&
-        a.every((x, i) => x === b[i])
-      );
-    else if (a instanceof BigInt64Array)
-      return (
-        b instanceof BigInt64Array &&
-        a.length === b.length &&
-        a.every((x, i) => x === b[i])
-      );
-    else if (a instanceof Float32Array)
-      return (
-        b instanceof Float32Array &&
-        a.length === b.length &&
-        a.every((x, i) => x === b[i])
-      );
-    else if (a instanceof Float64Array)
-      return (
-        b instanceof Float64Array &&
-        a.length === b.length &&
-        a.every((x, i) => x === b[i])
-      );
-    else if (a instanceof ArrayBuffer) {
-      if (!(b instanceof ArrayBuffer) || a.byteLength !== b.byteLength)
-        return false;
-      const x: Uint8Array = new Uint8Array(a);
-      const y: Uint8Array = new Uint8Array(b);
-      return x.every((v, i) => v === y[i]);
-    } else if (a instanceof SharedArrayBuffer) {
-      if (!(b instanceof SharedArrayBuffer) || a.byteLength !== b.byteLength)
-        return false;
-      const x: Uint8Array = new Uint8Array(a);
-      const y: Uint8Array = new Uint8Array(b);
-      return x.every((v, i) => v === y[i]);
-    } else if (a instanceof DataView) {
-      if (!(b instanceof DataView) || a.byteLength !== b.byteLength)
-        return false;
-      const x: Uint8Array = new Uint8Array(a.buffer);
-      const y: Uint8Array = new Uint8Array(b.buffer);
-      return x.every((v, i) => v === y[i]);
-    } else if (a instanceof File)
+
+    if (typeof File !== "undefined" && a instanceof File)
       return (
         b instanceof File &&
         a.name === b.name &&
         a.size === b.size &&
         a.type === b.type &&
-        next(a.slice(), b.slice())
+        a.lastModified === b.lastModified
       );
-    // JUST PLAIN OBJECTS
-    else if (a !== null && b !== null) {
-      if (visited.has(a) && visited.get(a)!.has(b))
-        return visited.get(a)!.get(b)!;
-      if (!visited.has(a)) visited.set(a, new WeakMap());
-      visited.get(a)!.set(b, true);
-      const res: boolean =
-        Object.keys(a).length === Object.keys(b).length &&
-        Object.keys(a).every((x) => next(a[x], b[x]));
-      visited.get(a)!.set(b, res);
-      return res;
+    if (typeof Blob !== "undefined" && a instanceof Blob)
+      return b instanceof Blob && a.size === b.size && a.type === b.type;
+
+    if (a instanceof DataView) {
+      if (!(b instanceof DataView) || a.byteLength !== b.byteLength)
+        return false;
+      return bytes(a.buffer, a.byteOffset, a.byteLength).every(
+        (value, index) =>
+          value === bytes(b.buffer, b.byteOffset, b.byteLength)[index],
+      );
+    }
+    if (ArrayBuffer.isView(a)) {
+      if (
+        !ArrayBuffer.isView(b) ||
+        b instanceof DataView ||
+        Object.getPrototypeOf(a) !== Object.getPrototypeOf(b) ||
+        a.byteLength !== b.byteLength
+      )
+        return false;
+      const x: Uint8Array = bytes(a.buffer, a.byteOffset, a.byteLength);
+      const y: Uint8Array = bytes(b.buffer, b.byteOffset, b.byteLength);
+      return x.every((value, index) => value === y[index]);
     }
-    return false;
+    if (a instanceof ArrayBuffer)
+      return (
+        b instanceof ArrayBuffer &&
+        a.byteLength === b.byteLength &&
+        bytes(a).every((value, index) => value === bytes(b)[index])
+      );
+    if (
+      typeof SharedArrayBuffer !== "undefined" &&
+      a instanceof SharedArrayBuffer
+    )
+      return (
+        b instanceof SharedArrayBuffer &&
+        a.byteLength === b.byteLength &&
+        bytes(a).every((value, index) => value === bytes(b)[index])
+      );
+
+    const keys: PropertyKey[] = Reflect.ownKeys(a).filter((key) =>
+      Object.prototype.propertyIsEnumerable.call(a, key),
+    );
+    return (
+      keys.length ===
+        Reflect.ownKeys(b).filter((key) =>
+          Object.prototype.propertyIsEnumerable.call(b, key),
+        ).length &&
+      keys.every(
+        (key) =>
+          Object.prototype.propertyIsEnumerable.call(b, key) &&
+          next((a as any)[key], (b as any)[key]),
+      )
+    );
   };
   return next;
 };
+
+const bytes = (
+  buffer: ArrayBufferLike,
+  byteOffset: number = 0,
+  byteLength: number = buffer.byteLength,
+): Uint8Array => new Uint8Array(buffer, byteOffset, byteLength);

package/src/internal/_notationAny.ts

@@ -1,3 +1,5 @@
+import { _notationAssign } from "./_notationAssign";
+
 export const _notationAny = (rename: (str: string) => string) => {
   const main = (input: any): any => {
     if (typeof input === "object")
@@ -29,9 +31,12 @@ export const _notationAny = (rename: (str: string) => string) => {
       else return object(input);
     return input;
   };
-  const object = (input: Record<string, any>) =>
-    Object.fromEntries(
-      Object.entries(input).map(([key, value]) => [rename(key), main(value)]),
-    );
+  const object = (input: Record<string, any>) => {
+    const output: Record<string, any> = {};
+    const sources: Record<string, string> = Object.create(null);
+    for (const [key, value] of Object.entries(input))
+      _notationAssign(output, sources, key, main(value), rename);
+    return output;
+  };
   return main;
 };

package/src/internal/_notationAssign.ts

@@ -0,0 +1,20 @@
+import { _notationKeyCollision } from "./_notationKeyCollision";
+
+export const _notationAssign = (
+  output: Record<string, any>,
+  sources: Record<string, string>,
+  source: string,
+  value: any,
+  rename: (str: string) => string,
+): void => {
+  const destination: string = rename(source);
+  if (Object.hasOwn(output, destination))
+    _notationKeyCollision(sources[destination]!, source, destination);
+  Object.defineProperty(output, destination, {
+    configurable: true,
+    enumerable: true,
+    value,
+    writable: true,
+  });
+  sources[destination] = source;
+};

package/src/internal/_notationCamel.ts

@@ -1,13 +1,34 @@
-import { __notationCapitalize } from "./private/__notationCapitalize";
-import { __notationUnsnake } from "./private/__notationUnsnake";
+import { __notationRename } from "./private/__notationRename";
 
-export const _notationCamel = __notationUnsnake({
+const _notationCamelSnake = (str: string): string => {
+  while (str.startsWith("_")) str = str.substring(1);
+  if (str.length === 0) return "";
+  const index: number = str.indexOf("_");
+  if (index < 0) return str.toLowerCase();
+  const middle: string | undefined = str[index + 1];
+  // A trailing underscore has no character to uppercase, so `CamelizeSnakeString`
+  // falls through to lowercasing the whole key (`foo_` -> `foo_`).
+  if (middle === undefined) return str.toLowerCase();
+  // A doubled underscore collapses to a single one before continuing.
+  return middle === "_"
+    ? _notationCamelSnake(
+        `${str.substring(0, index)}_${str.substring(index + 2)}`,
+      )
+    : `${str
+        .substring(0, index)
+        .toLowerCase()}${middle.toUpperCase()}${_notationCamelSnake(
+        str.substring(index + 2),
+      )}`;
+};
+
+export const _notationCamel = __notationRename({
+  // `CamelCase<T>` lowercases an all-caps key and otherwise lowercases only the
+  // first character of an underscore-free key (`HTTP` -> `http`, `userID` stays).
   plain: (str) =>
-    str.length
-      ? str === str.toUpperCase()
-        ? str.toLocaleLowerCase()
-        : `${str[0]!.toLowerCase()}${str.substring(1)}`
-      : str,
-  snake: (str, i) =>
-    i === 0 ? str.toLowerCase() : __notationCapitalize(str.toLowerCase()),
+    str === str.toUpperCase()
+      ? str.toLowerCase()
+      : `${str[0]!.toLowerCase()}${str.substring(1)}`,
+  // With an underscore present, the character after each underscore is
+  // uppercased and the rest lowercased, matching `CamelizeSnakeString`.
+  snake: _notationCamelSnake,
 });

package/src/internal/_notationKebab.ts

@@ -0,0 +1,11 @@
+import { _notationSnake } from "./_notationSnake";
+
+export const _notationKebab = (str: string): string => {
+  let snaked: string = _notationSnake(str);
+  let prefix: string = "";
+  while (snaked.startsWith("_")) {
+    prefix += "_";
+    snaked = snaked.substring(1);
+  }
+  return `${prefix}${snaked.replaceAll("_", "-")}`;
+};

package/src/internal/_notationKeyCollision.ts

@@ -0,0 +1,9 @@
+export const _notationKeyCollision = (
+  first: string,
+  second: string,
+  destination: string,
+): never => {
+  throw new Error(
+    `typia.notations cannot rename both ${JSON.stringify(first)} and ${JSON.stringify(second)} to ${JSON.stringify(destination)}.`,
+  );
+};

package/src/internal/_notationPascal.ts

@@ -1,8 +1,21 @@
-import { __notationCapitalize } from "./private/__notationCapitalize";
-import { __notationUnsnake } from "./private/__notationUnsnake";
+import { __notationRename } from "./private/__notationRename";
 
-export const _notationPascal = __notationUnsnake({
-  plain: (str) =>
-    str.length ? `${str[0]!.toUpperCase()}${str.substring(1)}` : str,
-  snake: __notationCapitalize,
+const _notationPascalSnake = (str: string): string => {
+  while (str.startsWith("_")) str = str.substring(1);
+  if (str.length === 0) return "";
+  const index: number = str.indexOf("_");
+  return index < 0
+    ? `${str[0]!.toUpperCase()}${str.substring(1).toLowerCase()}`
+    : `${str[0]!.toUpperCase()}${str
+        .substring(1, index)
+        .toLowerCase()}${_notationPascalSnake(str.substring(index + 1))}`;
+};
+
+export const _notationPascal = __notationRename({
+  // `PascalCase<T>` capitalizes the first character of an underscore-free key
+  // and keeps the rest verbatim (`userID` -> `UserID`).
+  plain: (str) => `${str[0]!.toUpperCase()}${str.substring(1)}`,
+  // With an underscore present, each segment is capitalized and its tail is
+  // lowercased (`MAX_COUNT` -> `MaxCount`), matching `PascalizeSnakeString`.
+  snake: _notationPascalSnake,
 });

package/src/internal/_notationSnake.ts

@@ -1,22 +1,4 @@
-export const _notationSnake = (str: string): string => {
-  if (str.length === 0) return str;
-
-  // PREFIX
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  let prefix: string = "";
-  for (let i: number = 0; i < str.length; i++) {
-    if (str[i] === "_") prefix += "_";
-    else break;
-  }
-  if (prefix.length !== 0) str = str.substring(prefix.length);
-
-  const out = (s: string) => `${prefix}${s}`;
-
-  // SNAKE CASE
-  const items: string[] = str.split("_");
-  if (items.length > 1) return out(items.map((s) => s.toLowerCase()).join("_"));
-
-  // CAMEL OR PASCAL CASE
+const _notationSnakeWord = (str: string): string => {
   const indexes: number[] = [];
   for (let i: number = 0; i < str.length; i++) {
     const code: number = str.charCodeAt(i);
@@ -28,7 +10,7 @@ export const _notationSnake = (str: string): string => {
     if (now - prev === 1) indexes.splice(i, 1);
   }
   if (indexes.length !== 0 && indexes[0] === 0) indexes.splice(0, 1);
-  if (indexes.length === 0) return out(str.toLowerCase());
+  if (indexes.length === 0) return str.toLowerCase();
 
   let ret: string = "";
   for (let i: number = 0; i < indexes.length; i++) {
@@ -39,5 +21,26 @@ export const _notationSnake = (str: string): string => {
     ret += "_";
   }
   ret += str.substring(indexes[indexes.length - 1]!).toLowerCase();
-  return out(ret);
+  return ret;
+};
+
+export const _notationSnake = (str: string): string => {
+  if (str.length === 0) return str;
+
+  // PREFIX
+  let prefix: string = "";
+  for (let i: number = 0; i < str.length; i++) {
+    if (str[i] === "_") prefix += "_";
+    else break;
+  }
+  if (prefix.length !== 0) str = str.substring(prefix.length);
+
+  // SNAKE CASE
+  //
+  // Run the case-boundary walk within each underscore-delimited segment, not
+  // over the whole segment at once. Lowercasing a segment atomically would drop
+  // the camelCase boundary inside it (`["fooBar", "baz"]` -> `["foobar", "baz"]`
+  // -> `foobar_baz`), diverging from `SnakeCase<T>`; the per-segment walk keeps
+  // it (`["foo_bar", "baz"]` -> `foo_bar_baz`).
+  return `${prefix}${str.split("_").map(_notationSnakeWord).join("_")}`;
 };