@typia/core 12.0.0-dev.20260225

package/src/programmers/IsProgrammer.ts

@@ -0,0 +1,278 @@
+import ts from "typescript";
+
+import { IProgrammerProps } from "../context/IProgrammerProps";
+import { ITypiaContext } from "../context/ITypiaContext";
+import { ExpressionFactory } from "../factories/ExpressionFactory";
+import { IdentifierFactory } from "../factories/IdentifierFactory";
+import { ValueFactory } from "../factories/ValueFactory";
+import { MetadataObjectType } from "../schemas/metadata/MetadataObjectType";
+import { MetadataSchema } from "../schemas/metadata/MetadataSchema";
+import { MetadataStorage } from "../schemas/metadata/MetadataStorage";
+import { FunctionProgrammer } from "./helpers/FunctionProgrammer";
+import { IExpressionEntry } from "./helpers/IExpressionEntry";
+import { OptionPredicator } from "./helpers/OptionPredicator";
+import { CheckerProgrammer } from "./internal/CheckerProgrammer";
+import { FeatureProgrammer } from "./internal/FeatureProgrammer";
+import { check_object } from "./iterate/check_object";
+
+/**
+ * Type guard code generator.
+ *
+ * Generates runtime type guard code returning boolean. Used by `typia.is<T>()`
+ * and `typia.equals<T>()`.
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ */
+export namespace IsProgrammer {
+  export const configure = (props: {
+    options?: Partial<CONFIG.IOptions>;
+    context: ITypiaContext;
+    functor: FunctionProgrammer;
+  }): CheckerProgrammer.IConfig => ({
+    prefix: "_i",
+    equals: !!props.options?.object,
+    trace: false,
+    path: false,
+    numeric: OptionPredicator.numeric({
+      numeric: props.options?.numeric,
+    }),
+    atomist: ({ entry }) =>
+      [
+        ...(entry.expression ? [entry.expression] : []),
+        ...(entry.conditions.length === 0
+          ? []
+          : [
+              entry.conditions
+                .map((set) =>
+                  set
+                    .map((s) => s.expression)
+                    .reduce((a, b) => ts.factory.createLogicalAnd(a, b)),
+                )
+                .reduce((a, b) => ts.factory.createLogicalOr(a, b)),
+            ]),
+      ].reduce((x, y) => ts.factory.createLogicalAnd(x, y)),
+    combiner: (next) => {
+      const initial: ts.TrueLiteral | ts.FalseLiteral =
+        next.logic === "and"
+          ? ts.factory.createTrue()
+          : ts.factory.createFalse();
+      const binder =
+        next.logic === "and"
+          ? ts.factory.createLogicalAnd
+          : ts.factory.createLogicalOr;
+      return next.binaries.length
+        ? next.binaries.map((binary) => binary.expression).reduce(binder)
+        : initial;
+    },
+    joiner: {
+      object: props.options?.object
+        ? (v) => props.options!.object!(v)
+        : (v) =>
+            check_object({
+              config: {
+                equals: !!props.options?.object,
+                undefined: OptionPredicator.undefined({
+                  undefined: props.options?.undefined,
+                }),
+                assert: true,
+                reduce: ts.factory.createLogicalAnd,
+                positive: ts.factory.createTrue(),
+                superfluous: () => ts.factory.createFalse(),
+              },
+              context: props.context,
+              entries: v.entries,
+              input: v.input,
+            }),
+      array: (props) =>
+        ts.factory.createCallExpression(
+          IdentifierFactory.access(props.input, "every"),
+          undefined,
+          [props.arrow],
+        ),
+      failure: () => ts.factory.createFalse(),
+    },
+    success: ts.factory.createTrue(),
+  });
+
+  export namespace CONFIG {
+    export interface IOptions {
+      numeric: boolean;
+      undefined: boolean;
+      object: (props: {
+        input: ts.Expression;
+        entries: IExpressionEntry<ts.Expression>[];
+      }) => ts.Expression;
+    }
+  }
+
+  /* -----------------------------------------------------------
+    WRITERS
+  ----------------------------------------------------------- */
+  export interface IConfig {
+    equals: boolean;
+  }
+  export interface IProps extends IProgrammerProps {
+    config: IConfig;
+  }
+
+  export const decompose = (props: {
+    context: ITypiaContext;
+    functor: FunctionProgrammer;
+    config: IConfig;
+    type: ts.Type;
+    name: string | undefined;
+  }): FeatureProgrammer.IDecomposed => {
+    // CONFIGURATION
+    const config: CheckerProgrammer.IConfig = {
+      ...configure({
+        options: {
+          object: (v) =>
+            check_object({
+              config: {
+                equals: props.config.equals,
+                undefined: OptionPredicator.undefined(props.context.options),
+                assert: true,
+                reduce: ts.factory.createLogicalAnd,
+                positive: ts.factory.createTrue(),
+                superfluous: () => ts.factory.createFalse(),
+              },
+              context: props.context,
+              entries: v.entries,
+              input: v.input,
+            }),
+          numeric: OptionPredicator.numeric(props.context.options),
+        },
+        context: props.context,
+        functor: props.functor,
+      }),
+      trace: props.config.equals,
+    };
+
+    // COMPOSITION
+    const composed: FeatureProgrammer.IComposed = CheckerProgrammer.compose({
+      ...props,
+      config,
+    });
+    return {
+      functions: composed.functions,
+      statements: composed.statements,
+      arrow: ts.factory.createArrowFunction(
+        undefined,
+        undefined,
+        composed.parameters,
+        composed.response,
+        undefined,
+        composed.body,
+      ),
+    };
+  };
+
+  export const write = (props: IProps) => {
+    const functor: FunctionProgrammer = new FunctionProgrammer(
+      props.modulo.getText(),
+    );
+    const result: FeatureProgrammer.IDecomposed = decompose({
+      config: props.config,
+      context: props.context,
+      functor,
+      type: props.type,
+      name: props.name,
+    });
+    return FeatureProgrammer.writeDecomposed({
+      modulo: props.modulo,
+      functor,
+      result,
+    });
+  };
+
+  export const write_function_statements = (props: {
+    context: ITypiaContext;
+    functor: FunctionProgrammer;
+    collection: MetadataStorage;
+  }) => {
+    const config: CheckerProgrammer.IConfig = configure(props);
+    const next = {
+      ...props,
+      config,
+    };
+    const objects: ts.VariableStatement[] =
+      CheckerProgrammer.write_object_functions(next);
+    const unions: ts.VariableStatement[] =
+      CheckerProgrammer.write_union_functions(next);
+    const arrays: ts.VariableStatement[] =
+      CheckerProgrammer.write_array_functions(next);
+    const tuples: ts.VariableStatement[] =
+      CheckerProgrammer.write_tuple_functions(next);
+
+    return [
+      ...objects.filter((_, i) =>
+        props.functor.hasLocal(`${config.prefix}o${i}`),
+      ),
+      ...unions.filter((_, i) =>
+        props.functor.hasLocal(`${config.prefix}u${i}`),
+      ),
+      ...arrays.filter((_, i) =>
+        props.functor.hasLocal(`${config.prefix}a${i}`),
+      ),
+      ...tuples.filter((_, i) =>
+        props.functor.hasLocal(`${config.prefix}t${i}`),
+      ),
+    ];
+  };
+
+  /* -----------------------------------------------------------
+    DECODERS
+  ----------------------------------------------------------- */
+  export const decode = (props: {
+    context: ITypiaContext;
+    functor: FunctionProgrammer;
+    metadata: MetadataSchema;
+    input: ts.Expression;
+    explore: CheckerProgrammer.IExplore;
+  }) =>
+    CheckerProgrammer.decode({
+      context: props.context,
+      config: configure(props),
+      functor: props.functor,
+      metadata: props.metadata,
+      input: props.input,
+      explore: props.explore,
+    });
+
+  export const decode_object = (props: {
+    context: ITypiaContext;
+    functor: FunctionProgrammer;
+    object: MetadataObjectType;
+    input: ts.Expression;
+    explore: FeatureProgrammer.IExplore;
+  }) =>
+    CheckerProgrammer.decode_object({
+      config: configure(props),
+      functor: props.functor,
+      object: props.object,
+      input: props.input,
+      explore: props.explore,
+    });
+
+  export const decode_to_json = (props: {
+    input: ts.Expression;
+    checkNull: boolean;
+  }): ts.Expression =>
+    ts.factory.createLogicalAnd(
+      ExpressionFactory.isObject({
+        checkArray: false,
+        checkNull: props.checkNull,
+        input: props.input,
+      }),
+      ts.factory.createStrictEquality(
+        ts.factory.createStringLiteral("function"),
+        ValueFactory.TYPEOF(IdentifierFactory.access(props.input, "toJSON")),
+      ),
+    );
+
+  export const decode_functional = (input: ts.Expression) =>
+    ts.factory.createStrictEquality(
+      ts.factory.createStringLiteral("function"),
+      ValueFactory.TYPEOF(input),
+    );
+}