@nestia/sdk 2.4.2 → 2.4.3

package/src/utils/ImportDictionary.ts

@@ -1,128 +1,125 @@
-import path from "path";
-import { HashMap } from "tstl/container/HashMap";
-import { HashSet } from "tstl/container/HashSet";
-import { Pair } from "tstl/utility/Pair";
-
-export class ImportDictionary {
-    private readonly components_: HashMap<Pair<string, boolean>, IComposition> =
-        new HashMap();
-
-    public constructor(public readonly file: string) {}
-
-    public empty(): boolean {
-        return this.components_.empty();
-    }
-
-    public external(props: ImportDictionary.IExternalProps): string {
-        const composition: IComposition = this.components_.take(
-            new Pair(props.library, props.type),
-            () => ({
-                location: `node_modules/${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 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(props.file.length - 3) === ".ts")
-                return props.file.substring(0, props.file.length - 3);
-            return props.file;
-        })();
-        const composition: IComposition = this.components_.take(
-            new Pair(file, props.type),
-            () => ({
-                location: file,
-                elements: new HashSet(),
-                default: false,
-                type: props.type,
-            }),
-        );
-        if (props.instance === null) {
-            composition.default = true;
-            if (props.name) composition.name = props.name;
-        } else composition.elements.insert(props.instance);
-        return props.instance ?? file;
-    }
-
-    public toScript(outDir: string): string {
-        const external: string[] = [];
-        const internal: string[] = [];
-
-        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: string[]) => {
-                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(
-                        `import ${c.type ? "type " : ""}${brackets.join(
-                            ", ",
-                        )} from "${c.location}";`,
-                    );
-                }
-            };
-
-        enroll((str) => str.indexOf(NODE_MODULES) !== -1)(external);
-        enroll((str) => str.indexOf(NODE_MODULES) === -1)(internal);
-
-        if (external.length && internal.length) external.push("");
-        return [...external, ...internal].join("\n");
-    }
-}
-export namespace ImportDictionary {
-    export interface IExternalProps {
-        type: boolean;
-        library: string;
-        instance: string | null;
-    }
-    export interface IInternalProps {
-        type: boolean;
-        file: string;
-        instance: string | null;
-        name?: string | null;
-    }
-}
-
-interface IComposition {
-    location: string;
-    type: boolean;
-    default: boolean;
-    name?: string;
-    elements: HashSet<string>;
-}
-
-const NODE_MODULES = "node_modules/";
+import path from "path";
+import { HashMap } from "tstl/container/HashMap";
+import { HashSet } from "tstl/container/HashSet";
+import { Pair } from "tstl/utility/Pair";
+
+export class ImportDictionary {
+  private readonly components_: HashMap<Pair<string, boolean>, IComposition> =
+    new HashMap();
+
+  public constructor(public readonly file: string) {}
+
+  public empty(): boolean {
+    return this.components_.empty();
+  }
+
+  public external(props: ImportDictionary.IExternalProps): string {
+    const composition: IComposition = this.components_.take(
+      new Pair(props.library, props.type),
+      () => ({
+        location: `node_modules/${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 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(props.file.length - 3) === ".ts")
+        return props.file.substring(0, props.file.length - 3);
+      return props.file;
+    })();
+    const composition: IComposition = this.components_.take(
+      new Pair(file, props.type),
+      () => ({
+        location: file,
+        elements: new HashSet(),
+        default: false,
+        type: props.type,
+      }),
+    );
+    if (props.instance === null) {
+      composition.default = true;
+      if (props.name) composition.name = props.name;
+    } else composition.elements.insert(props.instance);
+    return props.instance ?? file;
+  }
+
+  public toScript(outDir: string): string {
+    const external: string[] = [];
+    const internal: string[] = [];
+
+    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: string[]) => {
+        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(
+            `import ${c.type ? "type " : ""}${brackets.join(", ")} from "${
+              c.location
+            }";`,
+          );
+        }
+      };
+
+    enroll((str) => str.indexOf(NODE_MODULES) !== -1)(external);
+    enroll((str) => str.indexOf(NODE_MODULES) === -1)(internal);
+
+    if (external.length && internal.length) external.push("");
+    return [...external, ...internal].join("\n");
+  }
+}
+export namespace ImportDictionary {
+  export interface IExternalProps {
+    type: boolean;
+    library: string;
+    instance: string | null;
+  }
+  export interface IInternalProps {
+    type: boolean;
+    file: string;
+    instance: string | null;
+    name?: string | null;
+  }
+}
+
+interface IComposition {
+  location: string;
+  type: boolean;
+  default: boolean;
+  name?: string;
+  elements: HashSet<string>;
+}
+
+const NODE_MODULES = "node_modules/";

package/src/utils/MapUtil.ts

@@ -1,14 +1,14 @@
-export namespace MapUtil {
-    export function take<Key, T>(
-        dict: Map<Key, T>,
-        key: Key,
-        generator: () => T,
-    ): T {
-        const oldbie: T | undefined = dict.get(key);
-        if (oldbie) return oldbie;
-
-        const value: T = generator();
-        dict.set(key, value);
-        return value;
-    }
-}
+export namespace MapUtil {
+  export function take<Key, T>(
+    dict: Map<Key, T>,
+    key: Key,
+    generator: () => T,
+  ): T {
+    const oldbie: T | undefined = dict.get(key);
+    if (oldbie) return oldbie;
+
+    const value: T = generator();
+    dict.set(key, value);
+    return value;
+  }
+}

package/src/utils/PathUtil.ts

@@ -1,10 +1,10 @@
-export namespace PathUtil {
-    export const accessors = (path: string) =>
-        path
-            .split("/")
-            .filter((str) => str.length && str[0] !== ":")
-            .map(normalize);
-
-    const normalize = (str: string) =>
-        str.split("-").join("_").split(".").join("_");
-}
+export namespace PathUtil {
+  export const accessors = (path: string) =>
+    path
+      .split("/")
+      .filter((str) => str.length && str[0] !== ":")
+      .map(normalize);
+
+  const normalize = (str: string) =>
+    str.split("-").join("_").split(".").join("_");
+}

package/src/utils/SourceFinder.ts

@@ -1,70 +1,66 @@
-import fs from "fs";
-import glob from "glob";
-import path from "path";
-
-export namespace SourceFinder {
-    interface IProps {
-        exclude?: string[];
-        include: string[];
-        filter: (location: string) => Promise<boolean>;
-    }
-
-    export const find = async (props: IProps): Promise<string[]> => {
-        const dict: Set<string> = new Set();
-
-        await emplace(props.filter)(props.include)((str) => dict.add(str));
-        if (props.exclude?.length)
-            await emplace(props.filter)(props.exclude)((str) =>
-                dict.delete(str),
-            );
-
-        return [...dict];
-    };
-
-    const emplace =
-        (filter: (file: string) => Promise<boolean>) =>
-        (input: string[]) =>
-        async (closure: (location: string) => void): Promise<void> => {
-            for (const pattern of input) {
-                if (_Is_file(pattern)) {
-                    closure(path.resolve(pattern));
-                    continue;
-                }
-                for (const file of await _Glob(pattern)) {
-                    const stats: fs.Stats = await fs.promises.stat(file);
-                    if (stats.isDirectory() === true)
-                        await iterate(filter)(closure)(file);
-                    else if (stats.isFile() && (await filter(file)))
-                        closure(file);
-                }
-            }
-        };
-
-    const iterate =
-        (filter: (location: string) => Promise<boolean>) =>
-        (closure: (location: string) => void) =>
-        async (location: string): Promise<void> => {
-            const directory: string[] = await fs.promises.readdir(location);
-            for (const file of directory) {
-                const next: string = path.resolve(`${location}/${file}`);
-                const stats: fs.Stats = await fs.promises.stat(next);
-
-                if (stats.isDirectory() === true)
-                    await iterate(filter)(closure)(next);
-                else if (stats.isFile() && (await filter(next))) closure(next);
-            }
-        };
-
-    const _Glob = (pattern: string): Promise<string[]> =>
-        new Promise((resolve, reject) => {
-            glob(pattern, (err, matches) => {
-                if (err) reject(err);
-                else resolve(matches.map((str) => path.resolve(str)));
-            });
-        });
-
-    const _Is_file = (pattern: string): boolean =>
-        pattern.endsWith(".ts") &&
-        !pattern.endsWith(".d.ts") &&
-        fs.existsSync(pattern);
-}
+import fs from "fs";
+import glob from "glob";
+import path from "path";
+
+export namespace SourceFinder {
+  interface IProps {
+    exclude?: string[];
+    include: string[];
+    filter: (location: string) => Promise<boolean>;
+  }
+
+  export const find = async (props: IProps): Promise<string[]> => {
+    const dict: Set<string> = new Set();
+
+    await emplace(props.filter)(props.include)((str) => dict.add(str));
+    if (props.exclude?.length)
+      await emplace(props.filter)(props.exclude)((str) => dict.delete(str));
+
+    return [...dict];
+  };
+
+  const emplace =
+    (filter: (file: string) => Promise<boolean>) =>
+    (input: string[]) =>
+    async (closure: (location: string) => void): Promise<void> => {
+      for (const pattern of input) {
+        if (_Is_file(pattern)) {
+          closure(path.resolve(pattern));
+          continue;
+        }
+        for (const file of await _Glob(pattern)) {
+          const stats: fs.Stats = await fs.promises.stat(file);
+          if (stats.isDirectory() === true)
+            await iterate(filter)(closure)(file);
+          else if (stats.isFile() && (await filter(file))) closure(file);
+        }
+      }
+    };
+
+  const iterate =
+    (filter: (location: string) => Promise<boolean>) =>
+    (closure: (location: string) => void) =>
+    async (location: string): Promise<void> => {
+      const directory: string[] = await fs.promises.readdir(location);
+      for (const file of directory) {
+        const next: string = path.resolve(`${location}/${file}`);
+        const stats: fs.Stats = await fs.promises.stat(next);
+
+        if (stats.isDirectory() === true) await iterate(filter)(closure)(next);
+        else if (stats.isFile() && (await filter(next))) closure(next);
+      }
+    };
+
+  const _Glob = (pattern: string): Promise<string[]> =>
+    new Promise((resolve, reject) => {
+      glob(pattern, (err, matches) => {
+        if (err) reject(err);
+        else resolve(matches.map((str) => path.resolve(str)));
+      });
+    });
+
+  const _Is_file = (pattern: string): boolean =>
+    pattern.endsWith(".ts") &&
+    !pattern.endsWith(".d.ts") &&
+    fs.existsSync(pattern);
+}

package/src/utils/StripEnums.ts

@@ -1,10 +1,5 @@
-export type StripEnums<T extends Record<string, any>> = {
-    [Key in keyof T]: T[Key] extends
-        | string
-        | boolean
-        | object
-        | undefined
-        | any[]
-        ? T[Key]
-        : any;
-};
+export type StripEnums<T extends Record<string, any>> = {
+  [Key in keyof T]: T[Key] extends string | boolean | object | undefined | any[]
+    ? T[Key]
+    : any;
+};