@nestia/sdk 4.2.0 → 4.3.0-dev.20241215-2

package/src/analyses/GenericAnalyzer.ts

@@ -1,49 +1,49 @@
-import ts from "typescript";
-
-export namespace GenericAnalyzer {
-  export function analyze(
-    checker: ts.TypeChecker,
-    classNode: ts.ClassDeclaration,
-  ): WeakMap<ts.Type, ts.Type> {
-    const dict: WeakMap<ts.Type, ts.Type> = new WeakMap();
-    explore(checker, dict, classNode);
-    return dict;
-  }
-
-  function explore(
-    checker: ts.TypeChecker,
-    dict: WeakMap<ts.Type, ts.Type>,
-    classNode: ts.ClassDeclaration,
-  ): void {
-    if (classNode.heritageClauses === undefined) return;
-
-    for (const heritage of classNode.heritageClauses)
-      for (const hType of heritage.types) {
-        // MUST BE CLASS
-        const expression: ts.Type = checker.getTypeAtLocation(hType.expression);
-        const superNode: ts.Declaration | undefined =
-          expression.symbol?.getDeclarations?.()?.[0];
-
-        if (superNode === undefined || !ts.isClassDeclaration(superNode))
-          continue;
-
-        // SPECIFY GENERICS
-        const usages: ReadonlyArray<ts.TypeNode> = hType.typeArguments || [];
-        const parameters: ReadonlyArray<ts.TypeParameterDeclaration> =
-          superNode.typeParameters || [];
-
-        parameters.forEach((param, index) => {
-          const paramType: ts.Type = checker.getTypeAtLocation(param);
-          const usageType: ts.Type =
-            usages[index] !== undefined
-              ? checker.getTypeAtLocation(usages[index])
-              : checker.getTypeAtLocation(param.default!);
-
-          dict.set(paramType, usageType);
-        });
-
-        // RECUSRIVE EXPLORATION
-        explore(checker, dict, superNode);
-      }
-  }
-}
+import ts from "typescript";
+
+export namespace GenericAnalyzer {
+  export function analyze(
+    checker: ts.TypeChecker,
+    classNode: ts.ClassDeclaration,
+  ): WeakMap<ts.Type, ts.Type> {
+    const dict: WeakMap<ts.Type, ts.Type> = new WeakMap();
+    explore(checker, dict, classNode);
+    return dict;
+  }
+
+  function explore(
+    checker: ts.TypeChecker,
+    dict: WeakMap<ts.Type, ts.Type>,
+    classNode: ts.ClassDeclaration,
+  ): void {
+    if (classNode.heritageClauses === undefined) return;
+
+    for (const heritage of classNode.heritageClauses)
+      for (const hType of heritage.types) {
+        // MUST BE CLASS
+        const expression: ts.Type = checker.getTypeAtLocation(hType.expression);
+        const superNode: ts.Declaration | undefined =
+          expression.symbol?.getDeclarations?.()?.[0];
+
+        if (superNode === undefined || !ts.isClassDeclaration(superNode))
+          continue;
+
+        // SPECIFY GENERICS
+        const usages: ReadonlyArray<ts.TypeNode> = hType.typeArguments || [];
+        const parameters: ReadonlyArray<ts.TypeParameterDeclaration> =
+          superNode.typeParameters || [];
+
+        parameters.forEach((param, index) => {
+          const paramType: ts.Type = checker.getTypeAtLocation(param);
+          const usageType: ts.Type =
+            usages[index] !== undefined
+              ? checker.getTypeAtLocation(usages[index])
+              : checker.getTypeAtLocation(param.default!);
+
+          dict.set(paramType, usageType);
+        });
+
+        // RECUSRIVE EXPLORATION
+        explore(checker, dict, superNode);
+      }
+  }
+}

package/src/analyses/ImportAnalyzer.ts

@@ -1,171 +1,171 @@
-import ts from "typescript";
-
-import { IReflectType } from "../structures/IReflectType";
-import { IReflectTypeImport } from "../structures/IReflectTypeImport";
-import { MapUtil } from "../utils/MapUtil";
-
-export namespace ImportAnalyzer {
-  export interface IOutput {
-    imports: IReflectTypeImport[];
-    type: IReflectType | null;
-  }
-  export const analyze = (
-    checker: ts.TypeChecker,
-    generics: WeakMap<ts.Type, ts.Type>,
-    type: ts.Type,
-  ): IOutput => {
-    const imports: Map<string, Set<string>> = new Map();
-    try {
-      type = escape(checker, type);
-      return {
-        type: explore({
-          checker,
-          generics,
-          imports,
-          type,
-        }),
-        imports: [...imports].map(([file, instances]) => ({
-          file,
-          instances: Array.from(instances),
-        })),
-      };
-    } catch {
-      return {
-        imports: [],
-        type: null,
-      };
-    }
-  };
-
-  export const unique = (
-    imports: IReflectTypeImport[],
-  ): IReflectTypeImport[] => {
-    const map: Map<string, Set<string>> = new Map();
-    imports.forEach(({ file, instances }) => {
-      const set: Set<string> = MapUtil.take(map, file, () => new Set());
-      instances.forEach((instance) => set.add(instance));
-    });
-    return [...map].map(([file, instances]) => ({
-      file,
-      instances: Array.from(instances),
-    }));
-  };
-
-  /* ---------------------------------------------------------
-    TYPE
-  --------------------------------------------------------- */
-  const escape = (checker: ts.TypeChecker, type: ts.Type): ts.Type => {
-    if (type.symbol && getNameOfSymbol(type.symbol) === "Promise") {
-      const generic: readonly ts.Type[] = checker.getTypeArguments(
-        type as ts.TypeReference,
-      );
-      if (generic.length !== 1)
-        throw new Error(
-          "Error on ImportAnalyzer.analyze(): invalid promise type.",
-        );
-      type = generic[0];
-    }
-    return type;
-  };
-
-  const getNameOfSymbol = (symbol: ts.Symbol): string =>
-    exploreName(
-      symbol.escapedName.toString(),
-      symbol.getDeclarations()?.[0]?.parent,
-    );
-
-  /* ---------------------------------------------------------
-    ESCAPED TEXT WITH IMPORT STATEMENTS
-  --------------------------------------------------------- */
-  const explore = (props: {
-    checker: ts.TypeChecker;
-    generics: WeakMap<ts.Type, ts.Type>;
-    imports: Map<string, Set<string>>;
-    type: ts.Type;
-  }): IReflectType => {
-    //----
-    // CONDITIONAL BRANCHES
-    //----
-    // DECOMPOSE GENERIC ARGUMENT
-    let type: ts.Type = props.type;
-    while (props.generics.has(type) === true) type = props.generics.get(type)!;
-
-    // PRIMITIVE
-    const symbol: ts.Symbol | undefined = type.aliasSymbol ?? type.symbol;
-
-    // UNION OR INTERSECT
-    if (type.aliasSymbol === undefined && type.isUnionOrIntersection()) {
-      const joiner: string = type.isIntersection() ? " & " : " | ";
-      return {
-        name: type.types
-          .map((child) =>
-            explore({
-              ...props,
-              type: child,
-            }),
-          )
-          .map(getEscapedText)
-          .join(joiner),
-      };
-    }
-    // NO SYMBOL
-    else if (symbol === undefined)
-      return {
-        name: props.checker.typeToString(
-          type,
-          undefined,
-          ts.TypeFormatFlags.NoTruncation,
-        ),
-      };
-
-    //----
-    // SPECIALIZATION
-    //----
-    const name: string = getNameOfSymbol(symbol);
-    const sourceFile: ts.SourceFile | undefined =
-      symbol.declarations?.[0]?.getSourceFile();
-    if (sourceFile === undefined) return { name };
-    else if (sourceFile.fileName.indexOf("typescript/lib") === -1) {
-      const set: Set<string> = MapUtil.take(
-        props.imports,
-        sourceFile.fileName,
-        () => new Set(),
-      );
-      set.add(name.split(".")[0]);
-    }
-
-    // CHECK GENERIC
-    const generic: readonly ts.Type[] = type.aliasSymbol
-      ? type.aliasTypeArguments ?? []
-      : props.checker.getTypeArguments(type as ts.TypeReference);
-    return generic.length
-      ? name === "Promise"
-        ? explore({
-            ...props,
-            type: generic[0],
-          })
-        : {
-            name,
-            typeArguments: generic.map((child) =>
-              explore({
-                ...props,
-                type: child,
-              }),
-            ),
-          }
-      : { name };
-  };
-
-  const exploreName = (name: string, decl?: ts.Node): string =>
-    decl && ts.isModuleBlock(decl)
-      ? exploreName(
-          `${decl.parent.name.getFullText().trim()}.${name}`,
-          decl.parent.parent,
-        )
-      : name;
-
-  const getEscapedText = (type: IReflectType): string =>
-    type.typeArguments
-      ? `${type.name}<${type.typeArguments.map(getEscapedText).join(", ")}>`
-      : type.name;
-}
+import ts from "typescript";
+
+import { IReflectType } from "../structures/IReflectType";
+import { IReflectTypeImport } from "../structures/IReflectTypeImport";
+import { MapUtil } from "../utils/MapUtil";
+
+export namespace ImportAnalyzer {
+  export interface IOutput {
+    imports: IReflectTypeImport[];
+    type: IReflectType | null;
+  }
+  export const analyze = (
+    checker: ts.TypeChecker,
+    generics: WeakMap<ts.Type, ts.Type>,
+    type: ts.Type,
+  ): IOutput => {
+    const imports: Map<string, Set<string>> = new Map();
+    try {
+      type = escape(checker, type);
+      return {
+        type: explore({
+          checker,
+          generics,
+          imports,
+          type,
+        }),
+        imports: [...imports].map(([file, instances]) => ({
+          file,
+          instances: Array.from(instances),
+        })),
+      };
+    } catch {
+      return {
+        imports: [],
+        type: null,
+      };
+    }
+  };
+
+  export const unique = (
+    imports: IReflectTypeImport[],
+  ): IReflectTypeImport[] => {
+    const map: Map<string, Set<string>> = new Map();
+    imports.forEach(({ file, instances }) => {
+      const set: Set<string> = MapUtil.take(map, file, () => new Set());
+      instances.forEach((instance) => set.add(instance));
+    });
+    return [...map].map(([file, instances]) => ({
+      file,
+      instances: Array.from(instances),
+    }));
+  };
+
+  /* ---------------------------------------------------------
+    TYPE
+  --------------------------------------------------------- */
+  const escape = (checker: ts.TypeChecker, type: ts.Type): ts.Type => {
+    if (type.symbol && getNameOfSymbol(type.symbol) === "Promise") {
+      const generic: readonly ts.Type[] = checker.getTypeArguments(
+        type as ts.TypeReference,
+      );
+      if (generic.length !== 1)
+        throw new Error(
+          "Error on ImportAnalyzer.analyze(): invalid promise type.",
+        );
+      type = generic[0];
+    }
+    return type;
+  };
+
+  const getNameOfSymbol = (symbol: ts.Symbol): string =>
+    exploreName(
+      symbol.escapedName.toString(),
+      symbol.getDeclarations()?.[0]?.parent,
+    );
+
+  /* ---------------------------------------------------------
+    ESCAPED TEXT WITH IMPORT STATEMENTS
+  --------------------------------------------------------- */
+  const explore = (props: {
+    checker: ts.TypeChecker;
+    generics: WeakMap<ts.Type, ts.Type>;
+    imports: Map<string, Set<string>>;
+    type: ts.Type;
+  }): IReflectType => {
+    //----
+    // CONDITIONAL BRANCHES
+    //----
+    // DECOMPOSE GENERIC ARGUMENT
+    let type: ts.Type = props.type;
+    while (props.generics.has(type) === true) type = props.generics.get(type)!;
+
+    // PRIMITIVE
+    const symbol: ts.Symbol | undefined = type.aliasSymbol ?? type.symbol;
+
+    // UNION OR INTERSECT
+    if (type.aliasSymbol === undefined && type.isUnionOrIntersection()) {
+      const joiner: string = type.isIntersection() ? " & " : " | ";
+      return {
+        name: type.types
+          .map((child) =>
+            explore({
+              ...props,
+              type: child,
+            }),
+          )
+          .map(getEscapedText)
+          .join(joiner),
+      };
+    }
+    // NO SYMBOL
+    else if (symbol === undefined)
+      return {
+        name: props.checker.typeToString(
+          type,
+          undefined,
+          ts.TypeFormatFlags.NoTruncation,
+        ),
+      };
+
+    //----
+    // SPECIALIZATION
+    //----
+    const name: string = getNameOfSymbol(symbol);
+    const sourceFile: ts.SourceFile | undefined =
+      symbol.declarations?.[0]?.getSourceFile();
+    if (sourceFile === undefined) return { name };
+    else if (sourceFile.fileName.indexOf("typescript/lib") === -1) {
+      const set: Set<string> = MapUtil.take(
+        props.imports,
+        sourceFile.fileName,
+        () => new Set(),
+      );
+      set.add(name.split(".")[0]);
+    }
+
+    // CHECK GENERIC
+    const generic: readonly ts.Type[] = type.aliasSymbol
+      ? type.aliasTypeArguments ?? []
+      : props.checker.getTypeArguments(type as ts.TypeReference);
+    return generic.length
+      ? name === "Promise"
+        ? explore({
+            ...props,
+            type: generic[0],
+          })
+        : {
+            name,
+            typeArguments: generic.map((child) =>
+              explore({
+                ...props,
+                type: child,
+              }),
+            ),
+          }
+      : { name };
+  };
+
+  const exploreName = (name: string, decl?: ts.Node): string =>
+    decl && ts.isModuleBlock(decl)
+      ? exploreName(
+          `${decl.parent.name.getFullText().trim()}.${name}`,
+          decl.parent.parent,
+        )
+      : name;
+
+  const getEscapedText = (type: IReflectType): string =>
+    type.typeArguments
+      ? `${type.name}<${type.typeArguments.map(getEscapedText).join(", ")}>`
+      : type.name;
+}

package/src/analyses/PathAnalyzer.ts

@@ -1,69 +1,69 @@
-import path from "path";
-import { Token, parse } from "path-to-regexp";
-
-export namespace PathAnalyzer {
-  export const join = (...args: string[]) =>
-    "/" +
-    _Trim(
-      path
-        .join(...args.filter((s) => !!s.length))
-        .split("\\")
-        .join("/"),
-    );
-
-  export const escape = (str: string): string | null => {
-    const args = _Parse(str);
-    if (args === null) return null;
-    return (
-      "/" +
-      args
-        .map((arg) => (arg.type === "param" ? `:${arg.value}` : arg.value))
-        .join("/")
-    );
-  };
-
-  export const parameters = (str: string): string[] | null => {
-    const args = _Parse(str);
-    if (args === null) return null;
-    return args.filter((arg) => arg.type === "param").map((arg) => arg.value);
-  };
-
-  function _Parse(str: string): IArgument[] | null {
-    const tokens: Token[] | null = (() => {
-      try {
-        return parse(path.join(str).split("\\").join("/"));
-      } catch {
-        return null;
-      }
-    })();
-    if (tokens === null) return null;
-
-    const output: IArgument[] = [];
-    for (const key of tokens) {
-      if (typeof key === "string")
-        output.push({
-          type: "path",
-          value: _Trim(key),
-        });
-      else if (typeof key.name === "number" || _Trim(key.name) === "")
-        return null;
-      else
-        output.push({
-          type: "param",
-          value: _Trim(key.name),
-        });
-    }
-    return output;
-  }
-
-  function _Trim(str: string): string {
-    if (str[0] === "/") str = str.substring(1);
-    if (str[str.length - 1] === "/") str = str.substring(0, str.length - 1);
-    return str;
-  }
-
-  interface IArgument {
-    type: "param" | "path";
-    value: string;
-  }
-}
+import path from "path";
+import { Token, parse } from "path-to-regexp";
+
+export namespace PathAnalyzer {
+  export const join = (...args: string[]) =>
+    "/" +
+    _Trim(
+      path
+        .join(...args.filter((s) => !!s.length))
+        .split("\\")
+        .join("/"),
+    );
+
+  export const escape = (str: string): string | null => {
+    const args = _Parse(str);
+    if (args === null) return null;
+    return (
+      "/" +
+      args
+        .map((arg) => (arg.type === "param" ? `:${arg.value}` : arg.value))
+        .join("/")
+    );
+  };
+
+  export const parameters = (str: string): string[] | null => {
+    const args = _Parse(str);
+    if (args === null) return null;
+    return args.filter((arg) => arg.type === "param").map((arg) => arg.value);
+  };
+
+  function _Parse(str: string): IArgument[] | null {
+    const tokens: Token[] | null = (() => {
+      try {
+        return parse(path.join(str).split("\\").join("/"));
+      } catch {
+        return null;
+      }
+    })();
+    if (tokens === null) return null;
+
+    const output: IArgument[] = [];
+    for (const key of tokens) {
+      if (typeof key === "string")
+        output.push({
+          type: "path",
+          value: _Trim(key),
+        });
+      else if (typeof key.name === "number" || _Trim(key.name) === "")
+        return null;
+      else
+        output.push({
+          type: "param",
+          value: _Trim(key.name),
+        });
+    }
+    return output;
+  }
+
+  function _Trim(str: string): string {
+    if (str[0] === "/") str = str.substring(1);
+    if (str[str.length - 1] === "/") str = str.substring(0, str.length - 1);
+    return str;
+  }
+
+  interface IArgument {
+    type: "param" | "path";
+    value: string;
+  }
+}