@nestia/sdk 2.4.7 → 2.5.0-dev.20240129

package/src/utils/FormatUtil.ts

@@ -0,0 +1,30 @@
+import { format } from "prettier";
+import ts from "typescript";
+
+export namespace FormatUtil {
+  export const description = <Node extends ts.Node>(
+    node: Node,
+    comment: string,
+  ): Node => {
+    ts.addSyntheticLeadingComment(
+      node,
+      ts.SyntaxKind.MultiLineCommentTrivia,
+      ["*", ...comment.split("\n").map((str) => ` * ${str}`), ""].join("\n"),
+      true,
+    );
+    return node;
+  };
+
+  export const enter = () =>
+    ts.factory.createExpressionStatement(ts.factory.createIdentifier("\n"));
+
+  export const beautify = async (script: string): Promise<string> => {
+    try {
+      return format(script, {
+        parser: "typescript",
+      });
+    } catch {
+      return script;
+    }
+  };
+}

package/src/utils/ImportDictionary.ts

@@ -2,6 +2,9 @@ import path from "path";
 import { HashMap } from "tstl/container/HashMap";
 import { HashSet } from "tstl/container/HashSet";
 import { Pair } from "tstl/utility/Pair";
+import ts from "typescript";
+
+import { FormatUtil } from "./FormatUtil";
 
 export class ImportDictionary {
   private readonly components_: HashMap<Pair<string, boolean>, IComposition> =
@@ -52,6 +55,75 @@ export class ImportDictionary {
     return props.instance ?? file;
   }
 
+  public toStatements(outDir: string): ts.Statement[] {
+    const external: ts.ImportDeclaration[] = [];
+    const internal: ts.ImportDeclaration[] = [];
+
+    const locator = (str: string) => {
+      const location: string = path.relative(outDir, str).split("\\").join("/");
+      const index: number = location.lastIndexOf(NODE_MODULES);
+      return index === -1
+        ? location.startsWith("..")
+          ? location
+          : `./${location}`
+        : location.substring(index + NODE_MODULES.length);
+    };
+    const enroll =
+      (filter: (str: string) => boolean) =>
+      (container: ts.ImportDeclaration[]) => {
+        const compositions: IComposition[] = this.components_
+          .toJSON()
+          .filter((c) => filter(c.second.location))
+          .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.name ?? c.location);
+          if (c.elements.empty() === false)
+            brackets.push(
+              `{ ${c.elements
+                .toJSON()
+                .sort((a, b) => a.localeCompare(b))
+                .join(", ")} }`,
+            );
+          container.push(
+            ts.factory.createImportDeclaration(
+              undefined,
+              ts.factory.createImportClause(
+                c.type,
+                c.default
+                  ? ts.factory.createIdentifier(c.name ?? c.location)
+                  : undefined,
+                c.elements.empty() === false
+                  ? ts.factory.createNamedImports(
+                      [...c.elements].map((elem) =>
+                        ts.factory.createImportSpecifier(
+                          false,
+                          undefined,
+                          ts.factory.createIdentifier(elem),
+                        ),
+                      ),
+                    )
+                  : undefined,
+              ),
+              ts.factory.createStringLiteral(c.location),
+            ),
+          );
+        }
+      };
+
+    enroll((str) => str.indexOf(NODE_MODULES) !== -1)(external);
+    enroll((str) => str.indexOf(NODE_MODULES) === -1)(internal);
+    return [
+      ...external,
+      ...(external.length && internal.length ? [FormatUtil.enter()] : []),
+      ...internal,
+    ];
+  }
+
   public toScript(outDir: string): string {
     const external: string[] = [];
     const internal: string[] = [];