typia 7.0.0-dev.20241002-2 → 7.0.0-dev.20241005

package/src/programmers/FeatureProgrammer.ts

@@ -13,7 +13,7 @@ import { MetadataObject } from "../schemas/metadata/MetadataObject";
 import { ITypiaContext } from "../transformers/ITypiaContext";
 
 import { CheckerProgrammer } from "./CheckerProgrammer";
-import { FunctionImporter } from "./helpers/FunctionImporter";
+import { FunctionProgrammer } from "./helpers/FunctionProgrammer";
 import { IExpressionEntry } from "./helpers/IExpressionEntry";
 import { UnionExplorer } from "./helpers/UnionExplorer";
 import { feature_object_entries } from "./internal/feature_object_entries";
@@ -47,7 +47,7 @@ export namespace FeatureProgrammer {
      */
     initializer: (props: {
       context: ITypiaContext;
-      importer: FunctionImporter;
+      functor: FunctionProgrammer;
       type: ts.Type;
     }) => [MetadataCollection, Metadata];
 
@@ -232,7 +232,7 @@ export namespace FeatureProgrammer {
   export const compose = (props: {
     context: ITypiaContext;
     config: IConfig;
-    importer: FunctionImporter;
+    functor: FunctionProgrammer;
     type: ts.Type;
     name: string | undefined;
   }): IComposed => {
@@ -292,7 +292,7 @@ export namespace FeatureProgrammer {
 
   export const writeDecomposed = (props: {
     modulo: ts.LeftHandSideExpression;
-    importer: FunctionImporter;
+    functor: FunctionProgrammer;
     result: IDecomposed;
   }): ts.CallExpression =>
     ts.factory.createCallExpression(
@@ -303,9 +303,9 @@ export namespace FeatureProgrammer {
         undefined,
         undefined,
         ts.factory.createBlock([
-          ...props.importer.declare(props.modulo),
+          ...props.functor.declare(props.modulo),
           ...Object.entries(props.result.functions)
-            .filter(([k]) => props.importer.hasLocal(k))
+            .filter(([k]) => props.functor.hasLocal(k))
             .map(([_k, v]) => v),
           ...props.result.statements,
           ts.factory.createReturnStatement(props.result.arrow),
@@ -318,7 +318,7 @@ export namespace FeatureProgrammer {
   export const write = (props: {
     context: ITypiaContext;
     config: IConfig;
-    importer: FunctionImporter;
+    functor: FunctionProgrammer;
     type: ts.Type;
     name?: string | undefined;
   }): ts.ArrowFunction => {
@@ -341,7 +341,7 @@ export namespace FeatureProgrammer {
         props.config.generator.objects?.(collection) ??
         write_object_functions({
           config: props.config,
-          importer: props.importer,
+          context: props.context,
           collection,
         }),
       unions:
@@ -371,16 +371,16 @@ export namespace FeatureProgrammer {
         [
           ...added,
           ...functions.objects.filter((_, i) =>
-            props.importer.hasLocal(`${props.config.prefix}o${i}`),
+            props.functor.hasLocal(`${props.config.prefix}o${i}`),
           ),
           ...functions.unions.filter((_, i) =>
-            props.importer.hasLocal(`${props.config.prefix}u${i}`),
+            props.functor.hasLocal(`${props.config.prefix}u${i}`),
           ),
           ...functions.arrays.filter((_, i) =>
-            props.importer.hasLocal(`${props.config.prefix}a${i}`),
+            props.functor.hasLocal(`${props.config.prefix}a${i}`),
           ),
           ...functions.tuples.filter((_, i) =>
-            props.importer.hasLocal(`${props.config.prefix}t${i}`),
+            props.functor.hasLocal(`${props.config.prefix}t${i}`),
           ),
           ...(ts.isBlock(output)
             ? output.statements
@@ -393,7 +393,7 @@ export namespace FeatureProgrammer {
 
   export const write_object_functions = (props: {
     config: IConfig;
-    importer: FunctionImporter;
+    context: ITypiaContext;
     collection: MetadataCollection;
   }) =>
     props.collection.objects().map((object) =>
@@ -413,7 +413,7 @@ export namespace FeatureProgrammer {
             input: ts.factory.createIdentifier("input"),
             entries: feature_object_entries({
               config: props.config,
-              importer: props.importer,
+              context: props.context,
               input: ts.factory.createIdentifier("input"),
               object,
             }),
@@ -466,7 +466,7 @@ export namespace FeatureProgrammer {
     ----------------------------------------------------------- */
   export const decode_array = (props: {
     config: Pick<IConfig, "trace" | "path" | "decoder" | "prefix">;
-    importer: FunctionImporter;
+    functor: FunctionProgrammer;
     combiner: (next: {
       input: ts.Expression;
       arrow: ts.ArrowFunction;
@@ -475,7 +475,7 @@ export namespace FeatureProgrammer {
     input: ts.Expression;
     explore: IExplore;
   }) => {
-    const rand: string = props.importer.increment().toString();
+    const rand: string = props.functor.increment().toString();
     const tail =
       props.config.path || props.config.trace
         ? [
@@ -517,14 +517,14 @@ export namespace FeatureProgrammer {
 
   export const decode_object = (props: {
     config: Pick<IConfig, "trace" | "path" | "prefix">;
-    importer: FunctionImporter;
+    functor: FunctionProgrammer;
     object: MetadataObject;
     input: ts.Expression;
     explore: IExplore;
   }) =>
     ts.factory.createCallExpression(
       ts.factory.createIdentifier(
-        props.importer.useLocal(`${props.config.prefix}o${props.object.index}`),
+        props.functor.useLocal(`${props.config.prefix}o${props.object.index}`),
       ),
       undefined,
       argumentsArray(props),

package/src/programmers/ImportProgrammer.ts

@@ -0,0 +1,109 @@
+import ts from "typescript";
+
+import { MapUtil } from "../utils/MapUtil";
+
+export class ImportProgrammer {
+  private readonly assets_: Map<string, IAsset> = new Map();
+
+  public constructor() {}
+
+  public namespace(props: { file: string; name: string }): ts.Identifier {
+    const asset: IAsset = this.take(props.file);
+    asset.namespace ??= props.name;
+    return ts.factory.createIdentifier(asset.namespace);
+  }
+
+  public toStatements(): ts.ImportDeclaration[] {
+    const statements: ts.ImportDeclaration[] = [];
+    for (const asset of this.assets_.values()) {
+      if (asset.namespace !== null)
+        statements.push(
+          ts.factory.createImportDeclaration(
+            undefined,
+            ts.factory.createImportClause(
+              false,
+              undefined,
+              ts.factory.createNamespaceImport(
+                ts.factory.createIdentifier(asset.namespace),
+              ),
+            ),
+            ts.factory.createStringLiteral(asset.file),
+          ),
+        );
+      if (asset.default !== null || asset.instances.size > 0)
+        statements.push(
+          ts.factory.createImportDeclaration(
+            undefined,
+            ts.factory.createImportClause(
+              false,
+              asset.default !== null
+                ? ts.factory.createIdentifier(asset.default)
+                : undefined,
+              asset.instances.size > 0
+                ? ts.factory.createNamedImports(
+                    [...asset.instances].map((name) =>
+                      ts.factory.createImportSpecifier(
+                        false,
+                        undefined,
+                        ts.factory.createIdentifier(name),
+                      ),
+                    ),
+                  )
+                : undefined,
+            ),
+            ts.factory.createStringLiteral(asset.file),
+            undefined,
+          ),
+        );
+    }
+    return statements;
+  }
+
+  /**
+   * @internal
+   */
+  public internal(name: string): ts.PropertyAccessExpression {
+    if (name.startsWith("$") === false) name = `$${name}`;
+    return ts.factory.createPropertyAccessExpression(
+      this.namespace({
+        file: `typia/lib/internal/${name}.js`,
+        name: alias(name),
+      }),
+      name,
+    );
+  }
+
+  /**
+   * @internal
+   */
+  public getInternalText(name: string): string {
+    if (name.startsWith("$") === false) name = `$${name}`;
+    const asset: IAsset | undefined = this.take(
+      `typia/lib/internal/${name}.js`,
+    );
+    if (asset === undefined)
+      throw new Error(`Internal asset not found: ${name}`);
+    return `${asset.namespace}.${name}`;
+  }
+
+  /**
+   * @internal
+   */
+  private take(file: string): IAsset {
+    return MapUtil.take(this.assets_, file, () => ({
+      file,
+      default: null,
+      namespace: null,
+      instances: new Set(),
+    }));
+  }
+}
+
+interface IAsset {
+  file: string;
+  default: string | null;
+  namespace: string | null;
+  instances: Set<string>;
+}
+
+const alias = (str: string) => `__${str}`;

package/src/programmers/IsProgrammer.ts

@@ -13,7 +13,7 @@ import { ITypiaContext } from "../transformers/ITypiaContext";
 
 import { CheckerProgrammer } from "./CheckerProgrammer";
 import { FeatureProgrammer } from "./FeatureProgrammer";
-import { FunctionImporter } from "./helpers/FunctionImporter";
+import { FunctionProgrammer } from "./helpers/FunctionProgrammer";
 import { IExpressionEntry } from "./helpers/IExpressionEntry";
 import { OptionPredicator } from "./helpers/OptionPredicator";
 import { check_object } from "./internal/check_object";
@@ -22,7 +22,7 @@ export namespace IsProgrammer {
   export const configure = (props: {
     options?: Partial<CONFIG.IOptions>;
     context: ITypiaContext;
-    importer: FunctionImporter;
+    functor: FunctionProgrammer;
   }): CheckerProgrammer.IConfig => ({
     prefix: "$i",
     equals: !!props.options?.object,
@@ -75,7 +75,6 @@ export namespace IsProgrammer {
                 superfluous: () => ts.factory.createFalse(),
               },
               context: props.context,
-              importer: props.importer,
               entries: v.entries,
               input: v.input,
             }),
@@ -113,7 +112,7 @@ export namespace IsProgrammer {
 
   export const decompose = (props: {
     context: ITypiaContext;
-    importer: FunctionImporter;
+    functor: FunctionProgrammer;
     config: IConfig;
     type: ts.Type;
     name: string | undefined;
@@ -133,14 +132,13 @@ export namespace IsProgrammer {
                 superfluous: () => ts.factory.createFalse(),
               },
               context: props.context,
-              importer: props.importer,
               entries: v.entries,
               input: v.input,
             }),
           numeric: OptionPredicator.numeric(props.context.options),
         },
         context: props.context,
-        importer: props.importer,
+        functor: props.functor,
       }),
       trace: props.config.equals,
     };
@@ -165,26 +163,26 @@ export namespace IsProgrammer {
   };
 
   export const write = (props: IProps) => {
-    const importer: FunctionImporter = new FunctionImporter(
+    const functor: FunctionProgrammer = new FunctionProgrammer(
       props.modulo.getText(),
     );
     const result: FeatureProgrammer.IDecomposed = decompose({
       config: props.config,
       context: props.context,
-      importer,
+      functor,
       type: props.type,
       name: props.name,
     });
     return FeatureProgrammer.writeDecomposed({
       modulo: props.modulo,
-      importer,
+      functor,
       result,
     });
   };
 
   export const write_function_statements = (props: {
     context: ITypiaContext;
-    importer: FunctionImporter;
+    functor: FunctionProgrammer;
     collection: MetadataCollection;
   }) => {
     const config: CheckerProgrammer.IConfig = configure(props);
@@ -203,16 +201,16 @@ export namespace IsProgrammer {
 
     return [
       ...objects.filter((_, i) =>
-        props.importer.hasLocal(`${config.prefix}o${i}`),
+        props.functor.hasLocal(`${config.prefix}o${i}`),
       ),
       ...unions.filter((_, i) =>
-        props.importer.hasLocal(`${config.prefix}u${i}`),
+        props.functor.hasLocal(`${config.prefix}u${i}`),
       ),
       ...arrays.filter((_, i) =>
-        props.importer.hasLocal(`${config.prefix}a${i}`),
+        props.functor.hasLocal(`${config.prefix}a${i}`),
       ),
       ...tuples.filter((_, i) =>
-        props.importer.hasLocal(`${config.prefix}t${i}`),
+        props.functor.hasLocal(`${config.prefix}t${i}`),
       ),
     ];
   };
@@ -222,7 +220,7 @@ export namespace IsProgrammer {
   ----------------------------------------------------------- */
   export const decode = (props: {
     context: ITypiaContext;
-    importer: FunctionImporter;
+    functor: FunctionProgrammer;
     metadata: Metadata;
     input: ts.Expression;
     explore: CheckerProgrammer.IExplore;
@@ -230,7 +228,7 @@ export namespace IsProgrammer {
     CheckerProgrammer.decode({
       context: props.context,
       config: configure(props),
-      importer: props.importer,
+      functor: props.functor,
       metadata: props.metadata,
       input: props.input,
       explore: props.explore,
@@ -238,14 +236,14 @@ export namespace IsProgrammer {
 
   export const decode_object = (props: {
     context: ITypiaContext;
-    importer: FunctionImporter;
+    functor: FunctionProgrammer;
     object: MetadataObject;
     input: ts.Expression;
     explore: FeatureProgrammer.IExplore;
   }) =>
     CheckerProgrammer.decode_object({
       config: configure(props),
-      importer: props.importer,
+      functor: props.functor,
       object: props.object,
       input: props.input,
       explore: props.explore,