typia 7.0.0-dev.20241011 → 7.0.0-dev.20241012

package/src/programmers/internal/check_union_array_like.ts

@@ -1,334 +1,334 @@
-import ts from "typescript";
-
-import { ExpressionFactory } from "../../factories/ExpressionFactory";
-import { IdentifierFactory } from "../../factories/IdentifierFactory";
-import { StatementFactory } from "../../factories/StatementFactory";
-import { TypeFactory } from "../../factories/TypeFactory";
-
-import { Metadata } from "../../schemas/metadata/Metadata";
-import { MetadataArray } from "../../schemas/metadata/MetadataArray";
-import { MetadataArrayType } from "../../schemas/metadata/MetadataArrayType";
-import { MetadataTuple } from "../../schemas/metadata/MetadataTuple";
-
-import { CheckerProgrammer } from "../CheckerProgrammer";
-import { FeatureProgrammer } from "../FeatureProgrammer";
-import { UnionExplorer } from "../helpers/UnionExplorer";
-
-/**
- * @internal
- */
-export const check_union_array_like = <
-  Origin extends Metadata | MetadataArray | MetadataTuple | Metadata.Entry,
-  Category extends MetadataArray | MetadataTuple,
-  Element,
->(props: {
-  config: check_union_array_like.IConfig<Category, Element>;
-  accessor: check_union_array_like.IAccessor<Origin, Category, Element>;
-  parameters: ts.ParameterDeclaration[];
-  input: ts.Expression;
-  definitions: Origin[];
-  explore: FeatureProgrammer.IExplore;
-}): ts.ArrowFunction => {
-  // ONLY ONE TYPE
-  const targets: Array<Category> = props.definitions.map(
-    props.accessor.transform,
-  );
-  if (targets.length === 1)
-    return ts.factory.createArrowFunction(
-      undefined,
-      undefined,
-      props.parameters,
-      undefined,
-      undefined,
-      props.config.decoder({
-        input: props.accessor.array(props.input),
-        definition: targets[0]!,
-        explore: props.explore,
-      }),
-    );
-
-  const array = ts.factory.createIdentifier("array");
-  const top = ts.factory.createIdentifier("top");
-
-  const statements: ts.Statement[] = [];
-  const tupleList: MetadataTuple[] = targets.filter(
-    (t) => t instanceof MetadataTuple,
-  ) as MetadataTuple[];
-  const arrayList: MetadataArray[] = targets.filter(
-    (t) => t instanceof MetadataArray,
-  ) as MetadataArray[];
-
-  const predicate = (meta: Category): ts.Expression =>
-    ts.factory.createAsExpression(
-      ts.factory.createArrayLiteralExpression(
-        [
-          ts.factory.createArrowFunction(
-            undefined,
-            undefined,
-            [
-              IdentifierFactory.parameter(
-                "top",
-                meta instanceof MetadataArrayType
-                  ? TypeFactory.keyword("any")
-                  : ts.factory.createTypeReferenceNode("any[]"),
-              ),
-            ],
-            TypeFactory.keyword("any"),
-            undefined,
-            props.config.checker({
-              input: ts.factory.createIdentifier("top"),
-              definition: props.accessor.element(meta),
-              explore: {
-                ...props.explore,
-                tracable: false,
-                postfix: meta instanceof MetadataArrayType ? `"[0]"` : "",
-              },
-              container: array,
-            }),
-          ),
-          ts.factory.createArrowFunction(
-            undefined,
-            undefined,
-            [
-              IdentifierFactory.parameter(
-                "entire",
-                ts.factory.createTypeReferenceNode("any[]"),
-              ),
-            ],
-            TypeFactory.keyword("any"),
-            undefined,
-            props.config.decoder({
-              input: ts.factory.createIdentifier("entire"),
-              definition: meta,
-              explore: {
-                ...props.explore,
-                tracable: true,
-              },
-            }),
-          ),
-        ],
-        true,
-      ),
-      ts.factory.createTypeReferenceNode("const"),
-    );
-  const iterate = (props: {
-    init: string;
-    from: ts.Expression;
-    if: ts.IfStatement;
-  }): ts.ForOfStatement =>
-    ts.factory.createForOfStatement(
-      undefined,
-      ts.factory.createVariableDeclarationList(
-        [ts.factory.createVariableDeclaration(props.init)],
-        ts.NodeFlags.Const,
-      ),
-      props.from,
-      props.if,
-    );
-
-  if (tupleList.length)
-    statements.push(
-      StatementFactory.constant({
-        name: "array",
-        value: props.accessor.array(props.input),
-      }),
-      StatementFactory.constant({
-        name: "tuplePredicators",
-        value: ts.factory.createArrayLiteralExpression(
-          tupleList.map((x) => predicate(x as Category)),
-          true,
-        ),
-      }),
-      iterate({
-        init: "pred",
-        from: ts.factory.createIdentifier("tuplePredicators"),
-        if: ts.factory.createIfStatement(
-          ts.factory.createCallExpression(
-            ts.factory.createIdentifier("pred[0]"),
-            undefined,
-            [array],
-          ),
-          ts.factory.createReturnStatement(
-            ts.factory.createCallExpression(
-              ts.factory.createIdentifier(`pred[1]`),
-              undefined,
-              [array],
-            ),
-          ),
-        ),
-      }),
-    );
-  if (arrayList.length) {
-    if (tupleList.length === 0)
-      statements.push(
-        StatementFactory.constant({
-          name: "array",
-          value: props.accessor.array(props.input),
-        }),
-      );
-    statements.push(
-      StatementFactory.constant({
-        name: "top",
-        value: props.accessor.front(props.input),
-      }),
-      ts.factory.createIfStatement(
-        ts.factory.createStrictEquality(
-          ExpressionFactory.number(0),
-          props.accessor.size(props.input),
-        ),
-        ts.isReturnStatement(props.config.empty)
-          ? props.config.empty
-          : ts.factory.createReturnStatement(props.config.empty),
-      ),
-      StatementFactory.constant({
-        name: "arrayPredicators",
-        value: ts.factory.createArrayLiteralExpression(
-          arrayList.map((x) => predicate(x as Category)),
-          true,
-        ),
-      }),
-      StatementFactory.constant({
-        name: "passed",
-        value: ts.factory.createCallExpression(
-          IdentifierFactory.access(
-            ts.factory.createIdentifier("arrayPredicators"),
-            "filter",
-          ),
-          undefined,
-          [
-            ts.factory.createArrowFunction(
-              undefined,
-              undefined,
-              [IdentifierFactory.parameter("pred")],
-              undefined,
-              undefined,
-              ts.factory.createCallExpression(
-                ts.factory.createIdentifier("pred[0]"),
-                undefined,
-                [top],
-              ),
-            ),
-          ],
-        ),
-      }),
-      ts.factory.createIfStatement(
-        ts.factory.createStrictEquality(
-          ExpressionFactory.number(1),
-          ts.factory.createIdentifier("passed.length"),
-        ),
-        ts.factory.createReturnStatement(
-          ts.factory.createCallExpression(
-            ts.factory.createElementAccessExpression(
-              ts.factory.createNonNullExpression(
-                ts.factory.createIdentifier("passed[0]"),
-              ),
-              1,
-            ),
-            undefined,
-            [array],
-          ),
-        ),
-        ts.factory.createIfStatement(
-          ts.factory.createLessThan(
-            ExpressionFactory.number(1),
-            ts.factory.createIdentifier("passed.length"),
-          ),
-          iterate({
-            init: "pred",
-            from: ts.factory.createIdentifier("passed"),
-            if: ts.factory.createIfStatement(
-              ts.factory.createCallExpression(
-                IdentifierFactory.access(array, "every"),
-                undefined,
-                [
-                  ts.factory.createArrowFunction(
-                    undefined,
-                    undefined,
-                    [
-                      IdentifierFactory.parameter(
-                        "value",
-                        TypeFactory.keyword("any"),
-                      ),
-                    ],
-                    undefined,
-                    undefined,
-                    ts.factory.createStrictEquality(
-                      props.config.success,
-                      ts.factory.createCallExpression(
-                        ts.factory.createIdentifier("pred[0]"),
-                        undefined,
-                        [ts.factory.createIdentifier("value")],
-                      ),
-                    ),
-                  ),
-                ],
-              ),
-              ts.factory.createReturnStatement(
-                ts.factory.createCallExpression(
-                  ts.factory.createIdentifier(`pred[1]`),
-                  undefined,
-                  [ts.factory.createIdentifier("array")],
-                ),
-              ),
-            ),
-          }),
-        ),
-      ),
-    );
-  }
-  statements.push(
-    props.config.failure({
-      input: props.input,
-      expected: `(${targets
-        .map((t) => props.accessor.name(t, props.accessor.element(t)))
-        .join(" | ")})`,
-      explore: props.explore,
-    }),
-  );
-  return ts.factory.createArrowFunction(
-    undefined,
-    undefined,
-    props.parameters,
-    undefined,
-    undefined,
-    ts.factory.createBlock(statements, true),
-  );
-};
-
-/**
- * @internal
- */
-export namespace check_union_array_like {
-  export interface IConfig<
-    Category extends MetadataArray | MetadataTuple,
-    Element,
-  > {
-    checker(props: {
-      input: ts.Expression;
-      definition: Element;
-      explore: FeatureProgrammer.IExplore;
-      container: ts.Expression;
-    }): ts.Expression;
-    decoder: UnionExplorer.Decoder<Category>;
-    empty: ts.ReturnStatement | ts.Expression;
-    success: ts.Expression;
-    failure(props: {
-      input: ts.Expression;
-      expected: string;
-      explore: CheckerProgrammer.IExplore;
-    }): ts.Statement;
-  }
-
-  export interface IAccessor<
-    Origin,
-    Category extends MetadataArray | MetadataTuple,
-    Element,
-  > {
-    transform(origin: Origin): Category;
-    element(meta: Category): Element;
-    name(meta: Category, elem: Element): string;
-    front(input: ts.Expression): ts.Expression;
-    array(input: ts.Expression): ts.Expression;
-    size(input: ts.Expression): ts.Expression;
-  }
-}
+import ts from "typescript";
+
+import { ExpressionFactory } from "../../factories/ExpressionFactory";
+import { IdentifierFactory } from "../../factories/IdentifierFactory";
+import { StatementFactory } from "../../factories/StatementFactory";
+import { TypeFactory } from "../../factories/TypeFactory";
+
+import { Metadata } from "../../schemas/metadata/Metadata";
+import { MetadataArray } from "../../schemas/metadata/MetadataArray";
+import { MetadataArrayType } from "../../schemas/metadata/MetadataArrayType";
+import { MetadataTuple } from "../../schemas/metadata/MetadataTuple";
+
+import { CheckerProgrammer } from "../CheckerProgrammer";
+import { FeatureProgrammer } from "../FeatureProgrammer";
+import { UnionExplorer } from "../helpers/UnionExplorer";
+
+/**
+ * @internal
+ */
+export const check_union_array_like = <
+  Origin extends Metadata | MetadataArray | MetadataTuple | Metadata.Entry,
+  Category extends MetadataArray | MetadataTuple,
+  Element,
+>(props: {
+  config: check_union_array_like.IConfig<Category, Element>;
+  accessor: check_union_array_like.IAccessor<Origin, Category, Element>;
+  parameters: ts.ParameterDeclaration[];
+  input: ts.Expression;
+  definitions: Origin[];
+  explore: FeatureProgrammer.IExplore;
+}): ts.ArrowFunction => {
+  // ONLY ONE TYPE
+  const targets: Array<Category> = props.definitions.map(
+    props.accessor.transform,
+  );
+  if (targets.length === 1)
+    return ts.factory.createArrowFunction(
+      undefined,
+      undefined,
+      props.parameters,
+      undefined,
+      undefined,
+      props.config.decoder({
+        input: props.accessor.array(props.input),
+        definition: targets[0]!,
+        explore: props.explore,
+      }),
+    );
+
+  const array = ts.factory.createIdentifier("array");
+  const top = ts.factory.createIdentifier("top");
+
+  const statements: ts.Statement[] = [];
+  const tupleList: MetadataTuple[] = targets.filter(
+    (t) => t instanceof MetadataTuple,
+  ) as MetadataTuple[];
+  const arrayList: MetadataArray[] = targets.filter(
+    (t) => t instanceof MetadataArray,
+  ) as MetadataArray[];
+
+  const predicate = (meta: Category): ts.Expression =>
+    ts.factory.createAsExpression(
+      ts.factory.createArrayLiteralExpression(
+        [
+          ts.factory.createArrowFunction(
+            undefined,
+            undefined,
+            [
+              IdentifierFactory.parameter(
+                "top",
+                meta instanceof MetadataArrayType
+                  ? TypeFactory.keyword("any")
+                  : ts.factory.createTypeReferenceNode("any[]"),
+              ),
+            ],
+            TypeFactory.keyword("any"),
+            undefined,
+            props.config.checker({
+              input: ts.factory.createIdentifier("top"),
+              definition: props.accessor.element(meta),
+              explore: {
+                ...props.explore,
+                tracable: false,
+                postfix: meta instanceof MetadataArrayType ? `"[0]"` : "",
+              },
+              container: array,
+            }),
+          ),
+          ts.factory.createArrowFunction(
+            undefined,
+            undefined,
+            [
+              IdentifierFactory.parameter(
+                "entire",
+                ts.factory.createTypeReferenceNode("any[]"),
+              ),
+            ],
+            TypeFactory.keyword("any"),
+            undefined,
+            props.config.decoder({
+              input: ts.factory.createIdentifier("entire"),
+              definition: meta,
+              explore: {
+                ...props.explore,
+                tracable: true,
+              },
+            }),
+          ),
+        ],
+        true,
+      ),
+      ts.factory.createTypeReferenceNode("const"),
+    );
+  const iterate = (props: {
+    init: string;
+    from: ts.Expression;
+    if: ts.IfStatement;
+  }): ts.ForOfStatement =>
+    ts.factory.createForOfStatement(
+      undefined,
+      ts.factory.createVariableDeclarationList(
+        [ts.factory.createVariableDeclaration(props.init)],
+        ts.NodeFlags.Const,
+      ),
+      props.from,
+      props.if,
+    );
+
+  if (tupleList.length)
+    statements.push(
+      StatementFactory.constant({
+        name: "array",
+        value: props.accessor.array(props.input),
+      }),
+      StatementFactory.constant({
+        name: "tuplePredicators",
+        value: ts.factory.createArrayLiteralExpression(
+          tupleList.map((x) => predicate(x as Category)),
+          true,
+        ),
+      }),
+      iterate({
+        init: "pred",
+        from: ts.factory.createIdentifier("tuplePredicators"),
+        if: ts.factory.createIfStatement(
+          ts.factory.createCallExpression(
+            ts.factory.createIdentifier("pred[0]"),
+            undefined,
+            [array],
+          ),
+          ts.factory.createReturnStatement(
+            ts.factory.createCallExpression(
+              ts.factory.createIdentifier(`pred[1]`),
+              undefined,
+              [array],
+            ),
+          ),
+        ),
+      }),
+    );
+  if (arrayList.length) {
+    if (tupleList.length === 0)
+      statements.push(
+        StatementFactory.constant({
+          name: "array",
+          value: props.accessor.array(props.input),
+        }),
+      );
+    statements.push(
+      StatementFactory.constant({
+        name: "top",
+        value: props.accessor.front(props.input),
+      }),
+      ts.factory.createIfStatement(
+        ts.factory.createStrictEquality(
+          ExpressionFactory.number(0),
+          props.accessor.size(props.input),
+        ),
+        ts.isReturnStatement(props.config.empty)
+          ? props.config.empty
+          : ts.factory.createReturnStatement(props.config.empty),
+      ),
+      StatementFactory.constant({
+        name: "arrayPredicators",
+        value: ts.factory.createArrayLiteralExpression(
+          arrayList.map((x) => predicate(x as Category)),
+          true,
+        ),
+      }),
+      StatementFactory.constant({
+        name: "passed",
+        value: ts.factory.createCallExpression(
+          IdentifierFactory.access(
+            ts.factory.createIdentifier("arrayPredicators"),
+            "filter",
+          ),
+          undefined,
+          [
+            ts.factory.createArrowFunction(
+              undefined,
+              undefined,
+              [IdentifierFactory.parameter("pred")],
+              undefined,
+              undefined,
+              ts.factory.createCallExpression(
+                ts.factory.createIdentifier("pred[0]"),
+                undefined,
+                [top],
+              ),
+            ),
+          ],
+        ),
+      }),
+      ts.factory.createIfStatement(
+        ts.factory.createStrictEquality(
+          ExpressionFactory.number(1),
+          ts.factory.createIdentifier("passed.length"),
+        ),
+        ts.factory.createReturnStatement(
+          ts.factory.createCallExpression(
+            ts.factory.createElementAccessExpression(
+              ts.factory.createNonNullExpression(
+                ts.factory.createIdentifier("passed[0]"),
+              ),
+              1,
+            ),
+            undefined,
+            [array],
+          ),
+        ),
+        ts.factory.createIfStatement(
+          ts.factory.createLessThan(
+            ExpressionFactory.number(1),
+            ts.factory.createIdentifier("passed.length"),
+          ),
+          iterate({
+            init: "pred",
+            from: ts.factory.createIdentifier("passed"),
+            if: ts.factory.createIfStatement(
+              ts.factory.createCallExpression(
+                IdentifierFactory.access(array, "every"),
+                undefined,
+                [
+                  ts.factory.createArrowFunction(
+                    undefined,
+                    undefined,
+                    [
+                      IdentifierFactory.parameter(
+                        "value",
+                        TypeFactory.keyword("any"),
+                      ),
+                    ],
+                    undefined,
+                    undefined,
+                    ts.factory.createStrictEquality(
+                      props.config.success,
+                      ts.factory.createCallExpression(
+                        ts.factory.createIdentifier("pred[0]"),
+                        undefined,
+                        [ts.factory.createIdentifier("value")],
+                      ),
+                    ),
+                  ),
+                ],
+              ),
+              ts.factory.createReturnStatement(
+                ts.factory.createCallExpression(
+                  ts.factory.createIdentifier(`pred[1]`),
+                  undefined,
+                  [ts.factory.createIdentifier("array")],
+                ),
+              ),
+            ),
+          }),
+        ),
+      ),
+    );
+  }
+  statements.push(
+    props.config.failure({
+      input: props.input,
+      expected: `(${targets
+        .map((t) => props.accessor.name(t, props.accessor.element(t)))
+        .join(" | ")})`,
+      explore: props.explore,
+    }),
+  );
+  return ts.factory.createArrowFunction(
+    undefined,
+    undefined,
+    props.parameters,
+    undefined,
+    undefined,
+    ts.factory.createBlock(statements, true),
+  );
+};
+
+/**
+ * @internal
+ */
+export namespace check_union_array_like {
+  export interface IConfig<
+    Category extends MetadataArray | MetadataTuple,
+    Element,
+  > {
+    checker(props: {
+      input: ts.Expression;
+      definition: Element;
+      explore: FeatureProgrammer.IExplore;
+      container: ts.Expression;
+    }): ts.Expression;
+    decoder: UnionExplorer.Decoder<Category>;
+    empty: ts.ReturnStatement | ts.Expression;
+    success: ts.Expression;
+    failure(props: {
+      input: ts.Expression;
+      expected: string;
+      explore: CheckerProgrammer.IExplore;
+    }): ts.Statement;
+  }
+
+  export interface IAccessor<
+    Origin,
+    Category extends MetadataArray | MetadataTuple,
+    Element,
+  > {
+    transform(origin: Origin): Category;
+    element(meta: Category): Element;
+    name(meta: Category, elem: Element): string;
+    front(input: ts.Expression): ts.Expression;
+    array(input: ts.Expression): ts.Expression;
+    size(input: ts.Expression): ts.Expression;
+  }
+}