@nestia/sdk 1.6.7-dev.20230830 → 2.0.0-dev.20230830

package/src/utils/ImportDictionary.ts

@@ -4,53 +4,117 @@ import { HashSet } from "tstl/container/HashSet";
 import { Pair } from "tstl/utility/Pair";
 
 export class ImportDictionary {
-    private readonly dict_: HashMap<string, Pair<boolean, HashSet<string>>> =
+    private readonly externals_: HashMap<Pair<string, boolean>, IComposition> =
+        new HashMap();
+    private readonly internals_: HashMap<Pair<string, boolean>, IComposition> =
         new HashMap();
 
     public empty(): boolean {
-        return this.dict_.empty();
+        return this.internals_.empty() && this.externals_.empty();
+    }
+
+    public external(props: ImportDictionary.IExternalProps): string {
+        const composition: IComposition = this.externals_.take(
+            new Pair(props.library, props.type),
+            () => ({
+                location: props.library,
+                elements: new HashSet(),
+                default: false,
+                type: props.type,
+            }),
+        );
+        if (props.instance === null) composition.default = true;
+        else composition.elements.insert(props.instance);
+        return props.instance ?? props.library;
     }
 
-    public emplace(file: string, realistic: boolean, instance: string): void {
-        if (file.substr(-5) === ".d.ts") file = file.substr(0, file.length - 5);
-        else if (file.substr(-3) === ".ts")
-            file = file.substr(0, file.length - 3);
-        else
+    public internal(props: ImportDictionary.IInternalProps): string {
+        const file: string = (() => {
+            if (props.file.substring(props.file.length - 5) === ".d.ts")
+                return props.file.substring(0, props.file.length - 5);
+            else if (props.file.substring(0, props.file.length - 3) === ".ts")
+                return props.file.substring(0, props.file.length - 3);
             throw new Error(
-                `Error on ImportDictionary.emplace(): extension of the target file "${file}" is not "ts".`,
+                `Error on ImportDictionary.emplace(): extension of the target file "${props.file}" is not "ts".`,
             );
-
-        const pair: Pair<boolean, HashSet<string>> = this.dict_.take(
-            file,
-            () => new Pair(realistic, new HashSet()),
+        })();
+        const composition: IComposition = this.internals_.take(
+            new Pair(file, props.type),
+            () => ({
+                location: file,
+                elements: new HashSet(),
+                default: false,
+                type: props.type,
+            }),
         );
-        pair.second.insert(instance);
+        if (props.instance === null) composition.default = true;
+        else composition.elements.insert(props.instance);
+        return props.instance ?? file;
     }
 
     public toScript(outDir: string): string {
         const statements: string[] = [];
-        for (const it of this.dict_) {
-            const file: string = (() => {
-                const location: string = path
-                    .relative(outDir, it.first)
-                    .split("\\")
-                    .join("/");
-                const index: number = location.lastIndexOf(NODE_MODULES);
-                return index === -1
-                    ? `./${location}`
-                    : location.substring(index + NODE_MODULES.length);
-            })();
-            const realistic: boolean = it.second.first;
-            const instances: string[] = it.second.second.toJSON();
-
-            statements.push(
-                `import ${!realistic ? "type " : ""}{ ${instances.join(
-                    ", ",
-                )} } from "${file}";`,
-            );
-        }
+        const enroll =
+            (locator: (str: string) => string) =>
+            (dict: HashMap<Pair<string, boolean>, IComposition>) => {
+                const compositions: IComposition[] = dict
+                    .toJSON()
+                    .map((e) => ({
+                        ...e.second,
+                        location: locator(e.second.location),
+                    }))
+                    .sort((a, b) => a.location.localeCompare(b.location));
+                for (const c of compositions) {
+                    const brackets: string[] = [];
+                    if (c.default) brackets.push(c.location);
+                    if (c.elements.empty() === false)
+                        brackets.push(
+                            `{${c.elements
+                                .toJSON()
+                                .sort((a, b) => a.localeCompare(b))
+                                .join(", ")}`,
+                        );
+                    statements.push(
+                        `import ${c.type ? "type " : ""} ${brackets.join(
+                            ", ",
+                        )} from "${c.location}";`,
+                    );
+                }
+            };
+
+        enroll((str) => str)(this.externals_);
+        if (this.internals_.size()) statements.push("");
+        enroll((str) => {
+            const location: string = path
+                .relative(outDir, str)
+                .split("\\")
+                .join("/");
+            const index: number = location.lastIndexOf(NODE_MODULES);
+            return index === -1
+                ? `./${location}`
+                : location.substring(index + NODE_MODULES.length);
+        })(this.internals_);
         return statements.join("\n");
     }
 }
+export namespace ImportDictionary {
+    export interface IInternalProps {
+        type: boolean;
+        file: string;
+        instance: string;
+    }
+    export interface IExternalProps {
+        type: boolean;
+        library: string;
+        instance: string | null;
+    }
+}
+
+interface IComposition {
+    location: string;
+    type: boolean;
+    default: boolean;
+    elements: HashSet<string>;
+}
 
 const NODE_MODULES = "node_modules/";