improved Grant types

src/generators/greasemonkey/index.ts

@@ -7,27 +7,25 @@ import {
 } from "./types";
 
 //TODO: finish creating the processor
-export const generateGreasemonkeyHeaders: HeaderGenerator = (
-    _packageInfo,
-    { grants = [] }
-) => {
-    const grantMap: Record<GreasemonkeyGrantOptions, GreasemonkeyGrants> = {
-        set: "GM.setValue",
-        get: "GM.getValue",
-        delete: "GM.deleteValue",
-        list: "GM.listValues",
-        notify: "GM.notification",
-        clip: "GM.setClipboard",
-        fetch: "GM.xmlHttpRequest",
-        unsafe: "unsafeWindow",
-    };
+export const generateGreasemonkeyHeaders: HeaderGenerator<GreasemonkeyGrantOptions> =
+    (_packageInfo, { grants = [] }) => {
+        const grantMap: Record<GreasemonkeyGrantOptions, GreasemonkeyGrants> = {
+            set: "GM.setValue",
+            get: "GM.getValue",
+            delete: "GM.deleteValue",
+            list: "GM.listValues",
+            notify: "GM.notification",
+            clip: "GM.setClipboard",
+            fetch: "GM.xmlHttpRequest",
+            unsafe: "unsafeWindow",
+        };
 
-    const grantHeaders = generateGrantHeaders<GreasemonkeyHeaders>(
-        grantMap,
-        grants
-    );
+        const grantHeaders = generateGrantHeaders<
+            GreasemonkeyHeaders,
+            GreasemonkeyGrantOptions
+        >(grantMap, grants);
 
-    const headers: HeaderEntries<GreasemonkeyHeaders> = [...grantHeaders];
+        const headers: HeaderEntries<GreasemonkeyHeaders> = [...grantHeaders];
 
-    return finalizeMonkeyHeaders(headers, 4);
-};
+        return finalizeMonkeyHeaders(headers, 4);
+    };

src/generators/index.ts

@@ -1,31 +1,36 @@
 import { GeneratorOptions } from "..";
 import { RequiredProps } from "../utils/common";
 import { PackageInfo } from "../utils/package";
+import { GreasemonkeyGrantOptions } from "./greasemonkey/types";
+import { TampermonkeyGrantOptions } from "./tampermonkey/types";
 
 declare global {
     interface String {
         padEnd<T extends string>(maxLength: number, fillString?: string): T;
     }
 }
 
+export type CommonGrantOptions = "get" | "set" | "list" | "delete" | "unsafe";
+
+export type GrantOptions =
+    | GreasemonkeyGrantOptions
+    | TampermonkeyGrantOptions
+    | CommonGrantOptions;
+
 export type UserScriptManagerName =
     | "tampermonkey"
     | "violentmonkey"
     | "greasemonkey";
 
-export type CommonGrantOptions = "get" | "set" | "list" | "delete" | "unsafe";
-
 export type CommonGrants = "none" | "unsafeWindow";
 
 export type CommonRunAt = "document-start" | "document-end" | "document-idle";
 
-export type HeaderGenerator = (
+export type HeaderGenerator<T extends GrantOptions> = (
     info: PackageInfo,
-    options: RequiredProps<GeneratorOptions, "spaces">
+    options: RequiredProps<GeneratorOptions<T>, "spaces">
 ) => string;
 
-export type GeneratorMap = { [P in UserScriptManagerName]: HeaderGenerator };
-
 export type CommonHeaders<T extends object = {}> = T & {
     description: string;
     exclude: string[];
@@ -52,7 +57,7 @@ export type HeaderEntries<T> = HeaderEntry<T>[];
  */
 export const generateGrantHeaders = <
     T extends CommonHeaders,
-    U extends string = CommonGrantOptions
+    U extends GrantOptions
 >(
     grantMap: Record<U, T["grant"]>,
     grants: U[]

src/generators/tampermonkey/index.ts

@@ -1,87 +1,88 @@
-import {
-    generateGrantHeaders,
-    HeaderEntries,
-    HeaderGenerator,
-} from "..";
-import { parseName } from "../../utils/common";
+import { generateGrantHeaders, HeaderEntries, HeaderGenerator } from "..";
 import { formatAuthor, parseAuthor } from "../../utils/author";
+import { parseName } from "../../utils/common";
 import { finalizeMonkeyHeaders } from "../common/monkey";
-import { TampermonkeyGrantOptions, TampermonkeyGrants, TampermonkeyHeaders } from "./types";
+import {
+    TampermonkeyGrantOptions,
+    TampermonkeyGrants,
+    TampermonkeyHeaders,
+} from "./types";
 
-export const generateTampermonkeyHeaders: HeaderGenerator = (
-    {
-        author,
-        contributors = [],
-        icon,
-        name,
-        description,
-        homepage,
-        bugs: { url: supportURL },
-        repository: { url: source },
-        version,
-    },
-    { spaces, matches = [], grants = [] }
-) => {
-    const parsedAuthor = parseAuthor(author);
-    const { packageName, scope } = parseName(name);
+export const generateTampermonkeyHeaders: HeaderGenerator<TampermonkeyGrantOptions> =
+    (
+        {
+            author,
+            contributors = [],
+            icon,
+            name,
+            description,
+            homepage,
+            bugs: { url: supportURL },
+            repository: { url: source },
+            version,
+        },
+        { spaces, matches = [], grants = [] }
+    ) => {
+        const parsedAuthor = parseAuthor(author);
+        const { packageName, scope } = parseName(name);
 
-    const matchHeaders: HeaderEntries<TampermonkeyHeaders> = matches.map(
-        (uri) => ["match", uri]
-    );
+        const matchHeaders: HeaderEntries<TampermonkeyHeaders> = matches.map(
+            (uri) => ["match", uri]
+        );
 
-    const grantMap: Record<TampermonkeyGrantOptions, TampermonkeyGrants> = {
-        set: "GM_setValue",
-        get: "GM_getValue",
-        delete: "GM_deleteValue",
-        list: "GM_listValues",
-        unsafe: "unsafeWindow",
-        change: "window.onurlchange",
-        close: "window.close",
-        focus: "window.focus",
-    };
+        const grantMap: Record<TampermonkeyGrantOptions, TampermonkeyGrants> = {
+            set: "GM_setValue",
+            get: "GM_getValue",
+            delete: "GM_deleteValue",
+            list: "GM_listValues",
+            unsafe: "unsafeWindow",
+            change: "window.onurlchange",
+            close: "window.close",
+            focus: "window.focus",
+        };
 
-    const grantHeaders = generateGrantHeaders<TampermonkeyHeaders, TampermonkeyGrantOptions>(
-        grantMap,
-        grants
-    );
+        const grantHeaders = generateGrantHeaders<
+            TampermonkeyHeaders,
+            TampermonkeyGrantOptions
+        >(grantMap, grants);
 
-    const headers: HeaderEntries<TampermonkeyHeaders> = [
-        ["author", formatAuthor(parsedAuthor)],
-        ["description", description],
-        ["homepage", homepage],
-        ...matchHeaders,
-        ...grantHeaders,
-        ["name", packageName],
-        ["source", source],
-        ["supportURL", supportURL],
-        ["version", version],
-    ];
+        const headers: HeaderEntries<TampermonkeyHeaders> = [
+            ["author", formatAuthor(parsedAuthor)],
+            ["description", description],
+            ["homepage", homepage],
+            ...matchHeaders,
+            ...grantHeaders,
+            ["name", packageName],
+            ["source", source],
+            ["supportURL", supportURL],
+            ["version", version],
+        ];
 
-    if (scope) headers.push(["namespace", scope]);
+        if (scope) headers.push(["namespace", scope]);
 
-    if (icon) headers.push(["icon", icon]);
+        if (icon) headers.push(["icon", icon]);
 
-    if (contributors.length) {
-        const formatted = contributors.map((contributor) =>
-            formatAuthor(parseAuthor(contributor))
-        );
-        headers.push(["contributors", formatted.join(", ")]);
-    }
+        if (contributors.length) {
+            const formatted = contributors.map((contributor) =>
+                formatAuthor(parseAuthor(contributor))
+            );
+            headers.push(["contributors", formatted.join(", ")]);
+        }
 
-    //Unused headers:
-    // @icon64 and @icon64URL
-    // @updateURL
-    // @downloadURL
-    // @include
-    // @exclude
-    // @require
-    // @resource
-    // @connect
-    // @run-at
-    // @antifeature
-    // @noframes
-    // @unwrap
-    // @nocompat
+        //Unused headers:
+        // @icon64 and @icon64URL
+        // @updateURL
+        // @downloadURL
+        // @include
+        // @exclude
+        // @require
+        // @resource
+        // @connect
+        // @run-at
+        // @antifeature
+        // @noframes
+        // @unwrap
+        // @nocompat
 
-    return finalizeMonkeyHeaders(headers, spaces);
-};
+        return finalizeMonkeyHeaders(headers, spaces);
+    };

src/generators/violentmonkey/index.ts

@@ -1,9 +1,10 @@
-import { HeaderEntries, HeaderGenerator } from "..";
+import { CommonGrantOptions, HeaderEntries, HeaderGenerator } from "..";
 import { finalizeMonkeyHeaders } from "../common/monkey";
 import { ViolentMonkeyHeaders } from "./types";
 
 //TODO: finish creating the processor
-export const generateViolentMonkeyHeaders: HeaderGenerator = ({}) => {
-    const headers: HeaderEntries<ViolentMonkeyHeaders> = [];
-    return finalizeMonkeyHeaders(headers, 4);
-};
+export const generateViolentMonkeyHeaders: HeaderGenerator<CommonGrantOptions> =
+    ({}) => {
+        const headers: HeaderEntries<ViolentMonkeyHeaders> = [];
+        return finalizeMonkeyHeaders(headers, 4);
+    };

src/index.ts

@@ -3,8 +3,8 @@ import { appendFile } from "fs/promises";
 import * as yargs from "yargs";
 import { hideBin } from "yargs/helpers";
 import {
-    CommonGrantOptions,
-    GeneratorMap,
+    GrantOptions,
+    HeaderGenerator,
     UserScriptManagerName,
 } from "./generators";
 import { generateGreasemonkeyHeaders } from "./generators/greasemonkey";
@@ -19,16 +19,16 @@ const names: UserScriptManagerName[] = [
     "violentmonkey",
 ];
 
-export type GeneratorOptions<T extends CommonGrantOptions[]> = {
+export type GeneratorOptions<T extends GrantOptions> = {
     packagePath: string;
     output: string;
     spaces?: number;
     matches?: string[];
-    grants?: T;
+    grants?: T[];
     direct?: boolean;
 };
 
-export const generate = async <T extends CommonGrantOptions[]>(
+export const generate = async <T extends GrantOptions>(
     type: UserScriptManagerName,
     {
         packagePath,
@@ -38,7 +38,7 @@ export const generate = async <T extends CommonGrantOptions[]>(
         ...rest
     }: GeneratorOptions<T>
 ) => {
-    const managerTypeMap: GeneratorMap = {
+    const managerTypeMap = {
         greasemonkey: generateGreasemonkeyHeaders,
         tampermonkey: generateTampermonkeyHeaders,
         violentmonkey: generateViolentMonkeyHeaders,
@@ -52,7 +52,9 @@ export const generate = async <T extends CommonGrantOptions[]>(
             return "";
         }
 
-        const content = managerTypeMap[type!](parsedPackage, {
+        const handler = managerTypeMap[type] as HeaderGenerator<T>;
+
+        const content = handler(parsedPackage, {
             ...rest,
             spaces,
             packagePath,
@@ -125,10 +127,10 @@ names.forEach((name) =>
         `generates ${scase(name)} headers`,
         sharedOpts,
         ({ d, g = [], m = [], o, p, s }) =>
-            generate(name, {
+            generate<GrantOptions>(name, {
                 direct: !!d,
                 matches: m.map(String),
-                grants: g as CommonGrantOptions[],
+                grants: g as GrantOptions[],
                 output: o,
                 packagePath: p,
                 spaces: s,