typia 5.3.12-dev.20240118 → 6.0.0-dev.20240119

package/src/functional/Namespace/json.ts

@@ -1,15 +0,0 @@
-import { $number } from "../$number";
-import { $rest } from "../$rest";
-import { $string } from "../$string";
-import { $tail } from "../$tail";
-import { $throws } from "../$throws";
-import { is } from "../is";
-
-export const stringify = (method: string) => ({
-  ...is(),
-  number: $number,
-  string: $string,
-  tail: $tail,
-  rest: $rest,
-  throws: $throws(`json.${method}`),
-});

package/src/functional/Namespace/misc.ts

@@ -1,14 +0,0 @@
-import { $any } from "../$any";
-import { $throws } from "../$throws";
-import { is } from "../is";
-
-export const clone = (method: string) => ({
-  ...is(),
-  throws: $throws(`misc.${method}`),
-  any: $any,
-});
-
-export const prune = (method: string) => ({
-  ...is(),
-  throws: $throws(`misc.${method}`),
-});

package/src/functional/Namespace/notations.ts

@@ -1,22 +0,0 @@
-import { NamingConvention } from "../../utils/NamingConvention";
-import { $convention } from "../$convention";
-import { $throws } from "../$throws";
-import { is } from "../is";
-
-export const camel = (method: string) => ({
-  ...base(method),
-  any: $convention(NamingConvention.camel),
-});
-export const pascal = (method: string) => ({
-  ...base(method),
-  any: $convention(NamingConvention.pascal),
-});
-export const snake = (method: string) => ({
-  ...base(method),
-  any: $convention(NamingConvention.snake),
-});
-
-const base = (method: string) => ({
-  ...is(),
-  throws: $throws(`notations.${method}`),
-});

package/src/functional/Namespace/protobuf.ts

@@ -1,20 +0,0 @@
-import { $ProtobufReader } from "../$ProtobufReader";
-import { $ProtobufSizer } from "../$ProtobufSizer";
-import { $ProtobufWriter } from "../$ProtobufWriter";
-import { $strlen } from "../$strlen";
-import { $throws } from "../$throws";
-import { is } from "../is";
-
-export const decode = (method: string) => ({
-  ...is(),
-  Reader: $ProtobufReader,
-  throws: $throws(`protobuf.${method}`),
-});
-
-export const encode = (method: string) => ({
-  ...is(),
-  Sizer: $ProtobufSizer,
-  Writer: $ProtobufWriter,
-  strlen: $strlen,
-  throws: $throws(method),
-});

package/src/functional/is.ts

@@ -1,10 +0,0 @@
-import { $is_between } from "./$is_between";
-import { $is_bigint_string } from "./$stoll";
-
-/**
- * @internal
- */
-export const is = () => ({
-  is_between: $is_between,
-  is_bigint_string: $is_bigint_string,
-});

package/src/programmers/helpers/FunctionImporeter.ts

@@ -1,87 +0,0 @@
-import ts from "typescript";
-
-import { IdentifierFactory } from "../../factories/IdentifierFactory";
-import { StatementFactory } from "../../factories/StatementFactory";
-import { TypeFactory } from "../../factories/TypeFactory";
-
-export class FunctionImporter {
-  private readonly used_: Set<string> = new Set();
-  private readonly local_: Set<string> = new Set();
-  private readonly unions_: Map<string, [string, ts.ArrowFunction]> = new Map();
-  private sequence_: number = 0;
-
-  public constructor(public readonly method: string) {}
-
-  public empty(): boolean {
-    return this.used_.size === 0;
-  }
-
-  public use(name: string): ts.Identifier {
-    this.used_.add(name);
-    return ts.factory.createIdentifier("$" + name);
-  }
-
-  public useLocal(name: string): string {
-    this.local_.add(name);
-    return name;
-  }
-
-  public hasLocal(name: string): boolean {
-    return this.local_.has(name);
-  }
-
-  public declare(
-    modulo: ts.LeftHandSideExpression,
-    includeUnions: boolean = true,
-  ): ts.Statement[] {
-    return [
-      ...[...this.used_].map((name) =>
-        StatementFactory.constant(
-          "$" + name,
-          IdentifierFactory.access(
-            ts.factory.createParenthesizedExpression(
-              ts.factory.createAsExpression(modulo, TypeFactory.keyword("any")),
-            ),
-          )(name),
-        ),
-      ),
-      ...(includeUnions === true
-        ? [...this.unions_.values()].map(([key, arrow]) =>
-            StatementFactory.constant(key, arrow),
-          )
-        : []),
-    ];
-  }
-
-  public declareUnions(): ts.Statement[] {
-    return [...this.unions_.values()].map(([key, arrow]) =>
-      StatementFactory.constant(key, arrow),
-    );
-  }
-
-  public increment(): number {
-    return ++this.sequence_;
-  }
-
-  public emplaceUnion(
-    prefix: string,
-    name: string,
-    factory: () => ts.ArrowFunction,
-  ): string {
-    const oldbie = this.unions_.get(name);
-    if (oldbie) return oldbie[0];
-
-    const index: number = this.unions_.size;
-    const accessor: string = `${prefix}p${index}`;
-
-    const tuple: [string, ReturnType<typeof factory>] = [accessor, null!];
-    this.unions_.set(name, tuple);
-    tuple[1] = factory();
-    return accessor;
-  }
-
-  public trace(): void {
-    console.log(...this.used_);
-    console.log(...this.local_);
-  }
-}

package/src/utils/NamingConvention/NamingConvention.ts

@@ -1,85 +0,0 @@
-import { StringUtil } from "../StringUtil";
-
-export function snake(str: string): string {
-  const indexes: number[] = [];
-  for (let i: number = 0; i < str.length; i++) {
-    const code: number = str.charCodeAt(i);
-    if (65 <= code && code <= 90) indexes.push(i);
-  }
-  for (let i: number = indexes.length - 1; i > 0; --i) {
-    const now: number = indexes[i]!;
-    const prev: number = indexes[i - 1]!;
-    if (now - prev === 1) indexes.splice(i, 1);
-  }
-  if (indexes.length !== 0 && indexes[0] === 0) indexes.splice(0, 1);
-  if (indexes.length === 0) return str.toLowerCase();
-
-  let ret: string = "";
-  for (let i: number = 0; i < indexes.length; i++) {
-    const first: number = i === 0 ? 0 : indexes[i - 1]!;
-    const last: number = indexes[i]!;
-
-    ret += str.substring(first, last).toLowerCase();
-    ret += "_";
-  }
-  ret += str.substring(indexes[indexes.length - 1]!).toLowerCase();
-  return ret;
-}
-
-export function camel(str: string): string {
-  str = removeSnake(str);
-  if (str.length === 0) return str;
-  else if (str[0] === str[0]!.toUpperCase())
-    return str[0]!.toLowerCase() + str.substring(1);
-  else if (
-    str[0] === "_" &&
-    str.length > 1 &&
-    str[1] === str[1]!.toLowerCase()
-  )
-    return "_" + str[1]!.toUpperCase() + str.substring(2);
-  else return str;
-}
-
-export function pascal(str: string): string {
-  str = removeSnake(str);
-  if (str.length === 0) return str;
-  else if (str[0] === str[0]!.toLowerCase())
-    return str[0]!.toUpperCase() + str.substring(1);
-  else if (
-    str[0] === "_" &&
-    str.length > 1 &&
-    str[1] === str[1]!.toLowerCase()
-  )
-    return "_" + str[1]!.toUpperCase() + str.substring(2);
-  else return str;
-}
-
-const removeSnake = (str: string): string => {
-  const indexes: [number, number][] = [];
-  for (let i: number = 0; i < str.length; i++) {
-    const ch: string = str[i]!;
-    if (ch !== "_") continue;
-
-    const last = indexes[indexes.length - 1];
-    if (last === undefined || last[0] + last[1] !== i) indexes.push([i, 1]);
-    else ++last[1];
-  }
-  if (indexes.length === 0) return str;
-
-  let ret: string = "";
-  for (let i: number = 0; i < indexes.length; i++) {
-    const [first] = indexes[i]!;
-    if (i === 0)
-      if (first === 0) ret += "_";
-      else ret += str.substring(0, first);
-    else {
-      const [prevFirst, prevLength] = indexes[i - 1]!;
-      const piece: string = str.substring(prevFirst + prevLength, first);
-      if (piece.length) ret += StringUtil.capitalize(piece);
-    }
-  }
-  const last = indexes[indexes.length - 1]!;
-  const piece: string = str.substring(last[0] + last[1]);
-  if (last.length) ret += StringUtil.capitalize(piece);
-  return ret;
-};

package/src/utils/NamingConvention/index.ts

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

package/src/utils/RandomGenerator/RandomGenerator.ts

@@ -1,78 +0,0 @@
-import RandExp from "randexp";
-
-const ALPHABETS = "abcdefghijklmnopqrstuvwxyz";
-
-/* -----------------------------------------------------------
-      REGULAR
-  ----------------------------------------------------------- */
-export const boolean = () => Math.random() < 0.5;
-
-export const integer = (min?: number, max?: number) => {
-  min ??= 0;
-  max ??= 100;
-  return Math.floor(Math.random() * (max - min + 1)) + min;
-};
-
-export const bigint = (min?: bigint, max?: bigint) => {
-  min ??= BigInt(0);
-  max ??= BigInt(100);
-  return BigInt(integer(Number(min), Number(max)));
-};
-
-export const number = (min?: number, max?: number) => {
-  min ??= 0;
-  max ??= 100;
-  return Math.random() * (max - min) + min;
-};
-
-export const string = (length?: number): string =>
-  new Array(length ?? integer(5, 10))
-    .fill(0)
-    .map(() => ALPHABETS[integer(0, ALPHABETS.length - 1)])
-    .join("");
-
-export const array = <T>(
-  closure: (index: number) => T,
-  count?: number,
-): T[] =>
-  new Array(count ?? length()).fill(0).map((_e, index) => closure(index));
-
-export const pick = <T>(array: T[]): T =>
-  array[integer(0, array.length - 1)]!;
-
-export const length = () => integer(0, 3);
-
-/* -----------------------------------------------------------
-      SECIAL FORMATS
-  ----------------------------------------------------------- */
-export const uuid = () =>
-  "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
-    const r = (Math.random() * 16) | 0;
-    const v = c === "x" ? r : (r & 0x3) | 0x8;
-    return v.toString(16);
-  });
-
-export const email = () => `${string(10)}@${string(10)}.${string(3)}`;
-
-export const url = () => `https://${string(10)}.${string(3)}`;
-
-export const ipv4 = () => array(() => integer(0, 255), 4).join(".");
-
-export const ipv6 = (): string =>
-  array(() => integer(0, 65535).toString(16), 8).join(":");
-
-export const pattern = (regex: RegExp): string => new RandExp(regex).gen();
-
-export const date = (min?: number, max?: number) => {
-  min ??= 0;
-  max ??= Date.now() * 2;
-  return new Date(number(min, max)).toISOString().substring(0, 10);
-};
-
-export const datetime = (min?: number, max?: number) => {
-  min ??= Date.now() - 30 * DAY;
-  max ??= Date.now() + 7 * DAY;
-  return new Date(number(min, max)).toISOString();
-};
-
-const DAY = 86400000;

package/src/utils/RandomGenerator/index.ts

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

package/src/utils/StringUtil/StringUtil.ts

@@ -1,2 +0,0 @@
-export const capitalize = (str: string) =>
-  str.length ? str[0]!.toUpperCase() + str.slice(1) : str;

package/src/utils/StringUtil/index.ts

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