npm - typia - Versions diffs - 8.0.3 → 8.1.0 - Mend

typia 8.0.3 → 8.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (501) hide show

package/lib/transformers/features/notations/NotationCreateValidateGeneralTransformer.d.mts ADDED Viewed

@@ -0,0 +1,4 @@
+import { ITransformProps } from "../../ITransformProps";
+export declare namespace NotationCreateValidateGeneralTransformer {
+    const transform: (rename: (str: string) => string) => (props: ITransformProps) => import("typescript").Expression | import("typescript").ArrowFunction;
+}

package/lib/transformers/features/notations/NotationGeneralTransformer.d.mts ADDED Viewed

@@ -0,0 +1,4 @@
+import { ITransformProps } from "../../ITransformProps";
+export declare namespace NotationGeneralTransformer {
+    const transform: (rename: (str: string) => string) => (props: ITransformProps) => import("typescript").CallExpression;
+}

package/lib/transformers/features/notations/NotationIsGeneralTransformer.d.mts ADDED Viewed

@@ -0,0 +1,4 @@
+import { ITransformProps } from "../../ITransformProps";
+export declare namespace NotationIsGeneralTransformer {
+    const transform: (rename: (str: string) => string) => (props: ITransformProps) => import("typescript").CallExpression;
+}

package/lib/transformers/features/notations/NotationValidateGeneralTransformer.d.mts ADDED Viewed

@@ -0,0 +1,4 @@
+import { ITransformProps } from "../../ITransformProps";
+export declare namespace NotationValidateGeneralTransformer {
+    const transform: (rename: (str: string) => string) => (props: ITransformProps) => import("typescript").CallExpression;
+}

package/lib/transformers/features/protobuf/ProtobufAssertDecodeTransformer.d.mts ADDED Viewed

@@ -0,0 +1,4 @@
+import { ITransformProps } from "../../ITransformProps";
+export declare namespace ProtobufAssertDecodeTransformer {
+    const transform: (props: ITransformProps) => import("typescript").CallExpression;
+}

package/lib/transformers/features/protobuf/ProtobufAssertEncodeTransformer.d.mts ADDED Viewed

@@ -0,0 +1,4 @@
+import { ITransformProps } from "../../ITransformProps";
+export declare namespace ProtobufAssertEncodeTransformer {
+    const transform: (props: ITransformProps) => import("typescript").CallExpression;
+}

package/lib/transformers/features/protobuf/ProtobufCreateAssertDecodeTransformer.d.mts ADDED Viewed

@@ -0,0 +1,4 @@
+import { ITransformProps } from "../../ITransformProps";
+export declare namespace ProtobufCreateAssertDecodeTransformer {
+    const transform: (props: ITransformProps) => import("typescript").Expression | import("typescript").ArrowFunction;
+}

package/lib/transformers/features/protobuf/ProtobufCreateAssertEncodeTransformer.d.mts ADDED Viewed

@@ -0,0 +1,4 @@
+import { ITransformProps } from "../../ITransformProps";
+export declare namespace ProtobufCreateAssertEncodeTransformer {
+    const transform: (props: ITransformProps) => import("typescript").Expression | import("typescript").ArrowFunction;
+}

package/lib/transformers/features/protobuf/ProtobufCreateDecodeTransformer.d.mts ADDED Viewed

@@ -0,0 +1,4 @@
+import { ITransformProps } from "../../ITransformProps";
+export declare namespace ProtobufCreateDecodeTransformer {
+    const transform: (props: ITransformProps) => import("typescript").Expression | import("typescript").ArrowFunction;
+}

package/lib/transformers/features/protobuf/ProtobufCreateEncodeTransformer.d.mts ADDED Viewed

@@ -0,0 +1,4 @@
+import { ITransformProps } from "../../ITransformProps";
+export declare namespace ProtobufCreateEncodeTransformer {
+    const transform: (props: ITransformProps) => import("typescript").Expression | import("typescript").ArrowFunction;
+}

package/lib/transformers/features/protobuf/ProtobufCreateIsDecodeTransformer.d.mts ADDED Viewed

@@ -0,0 +1,4 @@
+import { ITransformProps } from "../../ITransformProps";
+export declare namespace ProtobufCreateIsDecodeTransformer {
+    const transform: (props: ITransformProps) => import("typescript").Expression | import("typescript").ArrowFunction;
+}

package/lib/transformers/features/protobuf/ProtobufCreateIsEncodeTransformer.d.mts ADDED Viewed

@@ -0,0 +1,4 @@
+import { ITransformProps } from "../../ITransformProps";
+export declare namespace ProtobufCreateIsEncodeTransformer {
+    const transform: (props: ITransformProps) => import("typescript").Expression | import("typescript").ArrowFunction;
+}

package/lib/transformers/features/protobuf/ProtobufCreateValidateDecodeTransformer.d.mts ADDED Viewed

@@ -0,0 +1,4 @@
+import { ITransformProps } from "../../ITransformProps";
+export declare namespace ProtobufCreateValidateDecodeTransformer {
+    const transform: (props: ITransformProps) => import("typescript").Expression | import("typescript").ArrowFunction;
+}

package/lib/transformers/features/protobuf/ProtobufCreateValidateEncodeTransformer.d.mts ADDED Viewed

@@ -0,0 +1,4 @@
+import { ITransformProps } from "../../ITransformProps";
+export declare namespace ProtobufCreateValidateEncodeTransformer {
+    const transform: (props: ITransformProps) => import("typescript").Expression | import("typescript").ArrowFunction;
+}

package/lib/transformers/features/protobuf/ProtobufDecodeTransformer.d.mts ADDED Viewed

@@ -0,0 +1,4 @@
+import { ITransformProps } from "../../ITransformProps";
+export declare namespace ProtobufDecodeTransformer {
+    const transform: (props: ITransformProps) => import("typescript").CallExpression;
+}

package/lib/transformers/features/protobuf/ProtobufEncodeTransformer.d.mts ADDED Viewed

@@ -0,0 +1,4 @@
+import { ITransformProps } from "../../ITransformProps";
+export declare namespace ProtobufEncodeTransformer {
+    const transform: (props: ITransformProps) => import("typescript").CallExpression;
+}

package/lib/transformers/features/protobuf/ProtobufIsDecodeTransformer.d.mts ADDED Viewed

@@ -0,0 +1,4 @@
+import { ITransformProps } from "../../ITransformProps";
+export declare namespace ProtobufIsDecodeTransformer {
+    const transform: (props: ITransformProps) => import("typescript").CallExpression;
+}

package/lib/transformers/features/protobuf/ProtobufIsEncodeTransformer.d.mts ADDED Viewed

@@ -0,0 +1,4 @@
+import { ITransformProps } from "../../ITransformProps";
+export declare namespace ProtobufIsEncodeTransformer {
+    const transform: (props: ITransformProps) => import("typescript").CallExpression;
+}

package/lib/transformers/features/protobuf/ProtobufMessageTransformer.d.mts ADDED Viewed

@@ -0,0 +1,5 @@
+import ts from "typescript";
+import { ITransformProps } from "../../ITransformProps";
+export declare namespace ProtobufMessageTransformer {
+    const transform: (props: Pick<ITransformProps, "context" | "expression">) => ts.Expression;
+}

package/lib/transformers/features/protobuf/ProtobufValidateDecodeTransformer.d.mts ADDED Viewed

@@ -0,0 +1,4 @@
+import { ITransformProps } from "../../ITransformProps";
+export declare namespace ProtobufValidateDecodeTransformer {
+    const transform: (props: ITransformProps) => import("typescript").CallExpression;
+}

package/lib/transformers/features/protobuf/ProtobufValidateEncodeTransformer.d.mts ADDED Viewed

@@ -0,0 +1,4 @@
+import { ITransformProps } from "../../ITransformProps";
+export declare namespace ProtobufValidateEncodeTransformer {
+    const transform: (props: ITransformProps) => import("typescript").CallExpression;
+}

package/lib/transformers/features/reflect/ReflectMetadataTransformer.d.mts ADDED Viewed

@@ -0,0 +1,5 @@
+import ts from "typescript";
+import { ITransformProps } from "../../ITransformProps";
+export declare namespace ReflectMetadataTransformer {
+    const transform: (props: Pick<ITransformProps, "context" | "expression">) => ts.Expression;
+}

package/lib/transformers/features/reflect/ReflectNameTransformer.d.mts ADDED Viewed

@@ -0,0 +1,5 @@
+import ts from "typescript";
+import { ITransformProps } from "../../ITransformProps";
+export declare namespace ReflectNameTransformer {
+    const transform: (props: Pick<ITransformProps, "context" | "expression">) => ts.Expression;
+}

package/lib/transformers/internal/GenericTransformer.d.mts ADDED Viewed

@@ -0,0 +1,11 @@
+import ts from "typescript";
+import { IProgrammerProps } from "../IProgrammerProps";
+import { ITransformProps } from "../ITransformProps";
+export declare namespace GenericTransformer {
+    interface IProps extends ITransformProps {
+        method: string;
+        write: (props: IProgrammerProps) => ts.Expression | ts.ArrowFunction;
+    }
+    const scalar: (props: IProps) => ts.CallExpression;
+    const factory: (props: IProps) => ts.Expression | ts.ArrowFunction;
+}

package/lib/typings/Atomic.d.mts ADDED Viewed

@@ -0,0 +1,11 @@
+export declare namespace Atomic {
+    type Type = boolean | number | string | bigint;
+    type Literal = "boolean" | "integer" | "number" | "string" | "bigint";
+    type Mapper = {
+        boolean: boolean;
+        integer: number;
+        number: number;
+        string: string;
+        bigint: bigint;
+    };
+}

package/lib/typings/ClassProperties.d.mts ADDED Viewed

@@ -0,0 +1,4 @@
+import { OmitNever } from "./OmitNever";
+export type ClassProperties<T extends object> = OmitNever<{
+    [K in keyof T]: T[K] extends Function ? never : T[K];
+}>;

package/lib/typings/Customizable.d.mts ADDED Viewed

@@ -0,0 +1,5 @@
+export type Customizable = {
+    number: number;
+    string: string;
+    bigint: bigint;
+};

package/lib/typings/Equal.d.mts ADDED Viewed

@@ -0,0 +1,15 @@
+/**
+ * Compare the equivalence of the two types X and Y.
+ *
+ * The two types X and Y refer to any type that can be expressed in the type script, such as the union type and the object type.
+ *
+ * @template X One of the types to compare
+ * @template Y One of the types to compare
+ *
+ * ```ts
+ * type Answer = Equal<1 | 2, 1 | 2>; // true
+ * ```
+ *
+ * @author Kyungsu Kang - https://github.com/kakasoo
+ */
+export type Equal<X, Y> = (<T>() => T extends X ? 1 : 2) extends <T>() => T extends Y ? 1 : 2 ? true : false;

package/lib/typings/IsTuple.d.mts ADDED Viewed

@@ -0,0 +1,5 @@
+export type IsTuple<T extends readonly any[] | {
+    length: number;
+}> = [
+    T
+] extends [never] ? false : T extends readonly any[] ? number extends T["length"] ? false : true : false;

package/lib/typings/NativeClass.d.mts ADDED Viewed

	@@ -0,0 +1 @@
1	+ export type NativeClass = Date \| Set<any> \| Map<any, any> \| WeakSet<any> \| WeakMap<any, any> \| Uint8Array \| Uint8ClampedArray \| Uint16Array \| Uint32Array \| BigUint64Array \| Int8Array \| Int16Array \| Int32Array \| BigInt64Array \| Float32Array \| Float64Array \| ArrayBuffer \| SharedArrayBuffer \| DataView \| Blob \| File \| RegExp;

package/lib/typings/OmitNever.d.mts ADDED Viewed

	@@ -0,0 +1,2 @@
1	+ import { SpecialFields } from "./SpecialFields";
2	+ export type OmitNever<T extends object> = Omit<T, SpecialFields<T, never>>;

package/lib/typings/ProtobufAtomic.d.mts ADDED Viewed

@@ -0,0 +1,5 @@
+export type ProtobufAtomic = "bool" | "int32" | "uint32" | "int64" | "uint64" | "float" | "double" | "string";
+export declare namespace ProtobufAtomic {
+    type Numeric = "int32" | "uint32" | "int64" | "uint64" | "float" | "double";
+    type BigNumeric = "int64" | "uint64";
+}

package/lib/typings/SpecialFields.d.mts ADDED Viewed

@@ -0,0 +1,3 @@
+export type SpecialFields<Instance extends object, Target> = {
+    [P in keyof Instance]: Instance[P] extends Target ? P : never;
+}[keyof Instance & string];

package/lib/typings/ValidationPipe.d.mts ADDED Viewed

@@ -0,0 +1,7 @@
+export type ValidationPipe<T, E> = {
+    success: true;
+    data: T;
+} | {
+    success: false;
+    errors: E[];
+};

package/lib/typings/ValueOf.d.mts ADDED Viewed

@@ -0,0 +1,6 @@
+export type ValueOf<Instance> = IsValueOf<Instance, Boolean> extends true ? boolean : IsValueOf<Instance, Number> extends true ? number : IsValueOf<Instance, String> extends true ? string : Instance;
+type IsValueOf<Instance, Object extends IValueOf<any>> = Instance extends Object ? Object extends IValueOf<infer Primitive> ? Instance extends Primitive ? false : true : false : false;
+interface IValueOf<T> {
+    valueOf(): T;
+}
+export {};

package/lib/typings/Writable.d.mts ADDED Viewed

@@ -0,0 +1,5 @@
+import { ClassProperties } from "./ClassProperties";
+export type Writable<T extends object> = {
+    -readonly [P in keyof T]: T[P];
+};
+export declare function Writable<T extends object>(elem: T): Writable<ClassProperties<T>>;

package/lib/utils/ArrayUtil.d.mts ADDED Viewed

@@ -0,0 +1,7 @@
+export declare namespace ArrayUtil {
+    const has: <T>(array: T[], pred: (elem: T) => boolean) => boolean;
+    const add: <T>(array: T[], value: T, pred?: (x: T, y: T) => boolean) => boolean;
+    const set: <Key, T>(array: T[], value: T, key: (elem: T) => Key) => void;
+    const take: <T>(array: T[], pred: (elem: T) => boolean, init: () => T) => T;
+    const repeat: <T>(count: number, closure: (index: number, count: number) => T) => T[];
+}

package/lib/utils/Escaper.d.mts ADDED Viewed

@@ -0,0 +1,4 @@
+export declare namespace Escaper {
+    const variable: (str: string) => boolean;
+    const reserved: (str: string) => boolean;
+}

package/lib/utils/MapUtil.d.mts ADDED Viewed

@@ -0,0 +1,3 @@
+export declare namespace MapUtil {
+    const take: <Key, T>(dict: Map<Key, T>, key: Key, generator: () => T) => T;
+}

package/lib/utils/NamingConvention.d.mts ADDED Viewed

@@ -0,0 +1,5 @@
+export declare namespace NamingConvention {
+    function snake(str: string): string;
+    function camel(str: string): string;
+    function pascal(str: string): string;
+}

package/lib/utils/PatternUtil.d.mts ADDED Viewed

@@ -0,0 +1,7 @@
+export declare namespace PatternUtil {
+    const fix: (str: string) => string;
+    const escape: (str: string) => string;
+    const NUMBER: string;
+    const BOOLEAN = "true|false";
+    const STRING = "(.*)";
+}

package/lib/utils/ProtobufNameEncoder.d.mts ADDED Viewed

@@ -0,0 +1,4 @@
+export declare namespace ProtobufNameEncoder {
+    const encode: (str: string) => string;
+    const decode: (str: string) => string;
+}

package/lib/utils/Singleton.d.mts ADDED Viewed

@@ -0,0 +1,6 @@
+export declare class Singleton<T, Args extends any[] = []> {
+    private readonly closure_;
+    private value_;
+    constructor(closure: (...args: Args) => T);
+    get(...args: Args): T;
+}

package/lib/utils/StringUtil.d.mts ADDED Viewed

@@ -0,0 +1,8 @@
+export declare namespace StringUtil {
+    const capitalize: (str: string) => string;
+    const escapeDuplicate: (props: {
+        keep: string[];
+        input: string;
+        escape?: (str: string) => string;
+    }) => string;
+}

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "typia",
-  "version": "8.0.3",
+  "version": "8.1.0",
   "description": "Superfast runtime validators with only one line",
   "main": "lib/index.js",
   "typings": "lib/index.d.ts",
@@ -27,8 +27,7 @@
     "------------------------------------------------": "",
     "package:latest": "ts-node deploy --tag latest",
     "package:next": "ts-node deploy --tag next",
-    "package:patch": "ts-node deploy --tag patch",
-    "preinstall": "npx only-allow pnpm"
+    "package:patch": "ts-node deploy --tag patch"
   },
   "repository": {
     "type": "git",
@@ -41,7 +40,7 @@
   },
   "homepage": "https://typia.io",
   "dependencies": {
-    "@samchon/openapi": "^3.0.0",
+    "@samchon/openapi": "^3.2.2",
     "commander": "^10.0.0",
     "comment-json": "^4.2.3",
     "inquirer": "^8.2.5",
@@ -49,7 +48,7 @@
     "randexp": "^0.5.3"
   },
   "peerDependencies": {
-    "@samchon/openapi": ">=3.0.0 <4.0.0",
+    "@samchon/openapi": ">=3.2.2 <4.0.0",
     "typescript": ">=4.8.0 <5.9.0"
   },
   "devDependencies": {