typia 7.0.0-dev.20240923 → 7.0.0-dev.20240928

package/src/programmers/notations/NotationGeneralProgrammer.ts

@@ -47,9 +47,11 @@ export namespace NotationGeneralProgrammer {
     const config = configure(props);
     if (props.validated === false)
       config.addition = (collection) =>
-        IsProgrammer.write_function_statements(props.context)(props.importer)(
+        IsProgrammer.write_function_statements({
+          context: props.context,
+          importer: props.importer,
           collection,
-        );
+        });
     const composed: FeatureProgrammer.IComposed = FeatureProgrammer.compose({
       ...props,
       config,
@@ -213,15 +215,14 @@ export namespace NotationGeneralProgrammer {
       unions.push({
         type: "tuple",
         is: () =>
-          IsProgrammer.decode(props.context)(props.importer)(
-            props.input,
-            (() => {
+          IsProgrammer.decode({
+            ...props,
+            metadata: (() => {
               const partial = Metadata.initialize();
               partial.tuples.push(tuple);
               return partial;
             })(),
-            props.explore,
-          ),
+          }),
         value: () =>
           decode_tuple({
             ...props,
@@ -484,7 +485,14 @@ export namespace NotationGeneralProgrammer {
   }): ts.Expression =>
     ts.factory.createCallExpression(
       UnionExplorer.set({
-        checker: IsProgrammer.decode(props.context)(props.importer),
+        checker: (input, metadata, explore) =>
+          IsProgrammer.decode({
+            context: props.context,
+            importer: props.importer,
+            input,
+            metadata,
+            explore,
+          }),
         decoder: (input, array, explore) =>
           ts.factory.createNewExpression(
             ts.factory.createIdentifier("Set"),
@@ -522,19 +530,29 @@ export namespace NotationGeneralProgrammer {
   }): ts.Expression =>
     ts.factory.createCallExpression(
       UnionExplorer.map({
-        checker: (top, entry, explore) => {
-          const func = IsProgrammer.decode(props.context)(props.importer);
-          return ts.factory.createLogicalAnd(
-            func(ts.factory.createElementAccessExpression(top, 0), entry[0], {
-              ...explore,
-              postfix: `${explore.postfix}[0]`,
+        checker: (top, entry, explore) =>
+          ts.factory.createLogicalAnd(
+            IsProgrammer.decode({
+              context: props.context,
+              importer: props.importer,
+              input: ts.factory.createElementAccessExpression(top, 0),
+              metadata: entry[0],
+              explore: {
+                ...props.explore,
+                postfix: `${explore.postfix}[0]`,
+              },
             }),
-            func(ts.factory.createElementAccessExpression(top, 1), entry[1], {
-              ...explore,
-              postfix: `${explore.postfix}[1]`,
+            IsProgrammer.decode({
+              context: props.context,
+              importer: props.importer,
+              input: ts.factory.createElementAccessExpression(top, 1),
+              metadata: entry[1],
+              explore: {
+                ...props.explore,
+                postfix: `${props.explore.postfix}[1]`,
+              },
             }),
-          );
-        },
+          ),
         decoder: (input, array, explore) =>
           ts.factory.createNewExpression(
             ts.factory.createIdentifier("Map"),
@@ -597,7 +615,14 @@ export namespace NotationGeneralProgrammer {
     explore_array_like_union_types({
       ...props,
       factory: UnionExplorer.array({
-        checker: IsProgrammer.decode(props.context)(props.importer),
+        checker: (input, metadata, explore) =>
+          IsProgrammer.decode({
+            context: props.context,
+            importer: props.importer,
+            input,
+            metadata,
+            explore,
+          }),
         decoder: (input, array, explore) =>
           decode_array({
             config: props.config,
@@ -645,7 +670,7 @@ export namespace NotationGeneralProgrammer {
         [],
       );
 
-    const explore: FeatureProgrammer.IExplore = {
+    const arrayExplore: FeatureProgrammer.IExplore = {
       ...props.explore,
       source: "function",
       from: "array",
@@ -661,13 +686,13 @@ export namespace NotationGeneralProgrammer {
                 TypeFactory.keyword("any"),
               )(ts.factory.createIdentifier("input")),
             )({
-              ...explore,
+              ...arrayExplore,
               postfix: "",
             })(ts.factory.createIdentifier("input")),
         ),
       ),
       undefined,
-      FeatureProgrammer.argumentsArray(props.config)(explore)(props.input),
+      FeatureProgrammer.argumentsArray(props.config)(arrayExplore)(props.input),
     );
   };
 
@@ -708,11 +733,24 @@ export namespace NotationGeneralProgrammer {
           input,
         }),
       objector: {
-        checker: () => IsProgrammer.decode(props.context)(props.importer),
+        checker: () => (input, metadata, explore) =>
+          IsProgrammer.decode({
+            context: props.context,
+            importer: props.importer,
+            input,
+            metadata,
+            explore,
+          }),
         decoder: () => decode_object(props.importer),
         joiner: NotationJoiner.object(props.rename),
-        unionizer: decode_union_object(
-          IsProgrammer.decode_object(props.context)(props.importer),
+        unionizer: decode_union_object((input, object, explore) =>
+          IsProgrammer.decode_object({
+            context: props.context,
+            importer: props.importer,
+            object,
+            input,
+            explore,
+          }),
         )(decode_object(props.importer))((exp) => exp)((input, expected) =>
           create_throw_error({
             importer: props.importer,

package/src/programmers/protobuf/ProtobufEncodeProgrammer.ts

@@ -179,9 +179,7 @@ export namespace ProtobufEncodeProgrammer {
         [
           ...props.importer.declareUnions(),
           ...functors,
-          ...IsProgrammer.write_function_statements(props.context)(
-            props.importer,
-          )(props.collection),
+          ...IsProgrammer.write_function_statements(props),
           ...main.statements,
           ts.factory.createReturnStatement(
             ts.factory.createIdentifier("writer"),
@@ -861,7 +859,14 @@ export namespace ProtobufEncodeProgrammer {
 
     if (specList.length === 0) {
       const condition: ts.Expression = decode_union_object(
-        IsProgrammer.decode_object(props.context)(props.importer),
+        (input, object, explore) =>
+          IsProgrammer.decode_object({
+            context: props.context,
+            importer: props.importer,
+            object,
+            input,
+            explore,
+          }),
       )((input, object, explore) =>
         ExpressionFactory.selfCall(
           decode_object({
@@ -895,15 +900,17 @@ export namespace ProtobufEncodeProgrammer {
           key,
         );
         const pred: ts.Expression = spec.neighbour
-          ? IsProgrammer.decode(props.context)(props.importer)(
-              accessor,
-              spec.property.value,
-              {
+          ? IsProgrammer.decode({
+              context: props.context,
+              importer: props.importer,
+              input: accessor,
+              metadata: spec.property.value,
+              explore: {
                 ...props.explore,
                 tracable: false,
                 postfix: IdentifierFactory.postfix(key),
               },
-            )
+            })
           : ExpressionFactory.isRequired(accessor);
         return ts.factory.createIfStatement(
           pred,

package/src/tags/Example.ts

@@ -0,0 +1,17 @@
+import { TagBase } from "./TagBase";
+
+export type Example<
+  Value extends boolean | bigint | number | string | Array<unknown> | null,
+> = TagBase<{
+  target: "boolean" | "bigint" | "number" | "string" | "array";
+  kind: "example";
+  value: Value;
+  exclusive: true;
+  schema: Value extends bigint
+    ? { example: Numeric<Value> }
+    : { example: Value };
+}>;
+
+type Numeric<T extends bigint> = `${T}` extends `${infer N extends number}`
+  ? N
+  : never;

package/src/tags/Examples.ts

@@ -0,0 +1,16 @@
+import { TagBase } from "./TagBase";
+
+export type Examples<
+  Dict extends Record<
+    string,
+    boolean | bigint | number | string | Array<unknown> | null
+  >,
+> = TagBase<{
+  target: "boolean" | "bigint" | "number" | "string" | "array";
+  kind: "examples";
+  value: Dict;
+  exclusive: true;
+  schema: {
+    examples: Dict;
+  };
+}>;

package/src/tags/index.ts

@@ -1,18 +1,20 @@
-export * from "./Constant";
-export * from "./ContentMediaType";
-export * from "./Default";
-export * from "./ExclusiveMaximum";
-export * from "./ExclusiveMinimum";
-export * from "./Format";
-export * from "./JsonSchemaPlugin";
-export * from "./Maximum";
-export * from "./MaxItems";
-export * from "./MaxLength";
-export * from "./Minimum";
-export * from "./MinItems";
-export * from "./MinLength";
-export * from "./MultipleOf";
-export * from "./Pattern";
-export * from "./TagBase";
-export * from "./Type";
-export * from "./UniqueItems";
+export * from "./Constant";
+export * from "./ContentMediaType";
+export * from "./Default";
+export * from "./Example";
+export * from "./Examples";
+export * from "./ExclusiveMaximum";
+export * from "./ExclusiveMinimum";
+export * from "./Format";
+export * from "./JsonSchemaPlugin";
+export * from "./Maximum";
+export * from "./MaxItems";
+export * from "./MaxLength";
+export * from "./Minimum";
+export * from "./MinItems";
+export * from "./MinLength";
+export * from "./MultipleOf";
+export * from "./Pattern";
+export * from "./TagBase";
+export * from "./Type";
+export * from "./UniqueItems";