Release

src/cli/builders/manifest/ManifestBase.ts

@@ -1,8 +1,9 @@
+import _ from "lodash";
+
 import {mergeWebAccessibleResources} from "./utils";
 
 import {
     CoreManifest,
-    FirefoxManifest,
     Manifest,
     ManifestAccessibleResource,
     ManifestAccessibleResources,
@@ -14,13 +15,13 @@ import {
     ManifestHostPermissions,
     ManifestIcons,
     ManifestIncognito,
-    ManifestPermissions,
     ManifestOptionalPermissions,
+    ManifestPermissions,
     ManifestPopup,
     ManifestSidebar,
     ManifestVersion,
 } from "@typing/manifest";
-import {Browser} from "@typing/browser";
+import {Browser, BrowserSpecific} from "@typing/browser";
 import {Language} from "@typing/locale";
 import {CommandExecuteActionName} from "@typing/command";
 import {DefaultIconGroupName} from "@typing/icon";
@@ -40,7 +41,6 @@ export class ManifestError extends Error {
 
 export default abstract class<T extends CoreManifest> implements ManifestBuilder<T> {
     protected name: string = "__MSG_app_name__";
-    protected email?: string;
     protected author?: string;
     protected homepage?: string;
     protected shortName?: string;
@@ -49,6 +49,7 @@ export default abstract class<T extends CoreManifest> implements ManifestBuilder
     protected version: string = "0.0.0";
     protected icon?: string;
     protected incognito?: ManifestIncognito;
+    protected specific?: BrowserSpecific;
     protected locale?: Language;
     protected icons: ManifestIcons = new Map();
     protected background?: ManifestBackground;
@@ -91,12 +92,6 @@ export default abstract class<T extends CoreManifest> implements ManifestBuilder
         return this;
     }
 
-    public setEmail(email?: string): this {
-        this.email = email;
-
-        return this;
-    }
-
     public setName(name: string): this {
         this.name = name;
 
@@ -139,6 +134,12 @@ export default abstract class<T extends CoreManifest> implements ManifestBuilder
         return this;
     }
 
+    public setSpecific(settings?: BrowserSpecific): this {
+        this.specific = settings;
+
+        return this;
+    }
+
     public setIcons(icons?: ManifestIcons): this {
         this.icons = icons || new Map();
 
@@ -464,13 +465,52 @@ export default abstract class<T extends CoreManifest> implements ManifestBuilder
         }
     }
 
-    protected buildBrowserSpecificSettings(): Partial<FirefoxManifest> | undefined {
-        if (this.browser === Browser.Firefox && this.email && this.permissions.has("storage")) {
+    protected buildBrowserSpecificSettings(): Partial<Manifest> | undefined {
+        const settings = this.specific || {};
+        const {safari, gecko, geckoAndroid} = settings;
+
+        if (this.browser === Browser.Firefox) {
+            const emptyGecko =
+                _.isEmpty(gecko?.id) &&
+                _.isEmpty(gecko?.strictMinVersion) &&
+                _.isEmpty(gecko?.strictMaxVersion) &&
+                _.isEmpty(gecko?.updateUrl);
+
+            const emptyGeckoAndroid =
+                _.isEmpty(geckoAndroid?.strictMinVersion) && _.isEmpty(geckoAndroid?.strictMaxVersion);
+
+            if (emptyGecko && emptyGeckoAndroid) {
+                return;
+            }
+
+            return {
+                browser_specific_settings: {
+                    gecko: emptyGecko
+                        ? undefined
+                        : {
+                              id: gecko?.id,
+                              strict_min_version: gecko?.strictMinVersion,
+                              strict_max_version: gecko?.strictMaxVersion,
+                              update_url: gecko?.updateUrl,
+                          },
+                    gecko_android: emptyGeckoAndroid
+                        ? undefined
+                        : {
+                              strict_min_version: geckoAndroid?.strictMinVersion,
+                              strict_max_version: geckoAndroid?.strictMaxVersion,
+                          },
+                },
+            };
+        } else if (this.browser === Browser.Safari) {
+            if (_.isEmpty(safari?.strictMinVersion) && _.isEmpty(safari?.strictMaxVersion)) {
+                return;
+            }
+
             return {
                 browser_specific_settings: {
-                    gecko: {
-                        id: this.email,
-                        // strict_min_version: this.minimumVersion,
+                    safari: {
+                        strict_min_version: safari?.strictMinVersion,
+                        strict_max_version: safari?.strictMaxVersion,
                     },
                 },
             };

src/cli/plugins/dotenv/index.ts

@@ -1,33 +1,21 @@
-import {createHash} from "crypto";
 import {DefinePlugin} from "@rspack/core";
 
 import {definePlugin} from "@main/plugin";
-
-import {encryptData} from "./crypt";
 import {filterEnvVars, resolveEnvOptions} from "./utils";
 
 import {type DotenvParseOutput} from "dotenv";
 
-const generateKey = (value: string): string => {
-    return createHash("sha256").update(value).digest("base64");
-};
-
 export default definePlugin((vars: DotenvParseOutput = {}) => {
     return {
         name: "adnbn:dotenv",
         bundler: ({config}) => {
-            const {filter, crypt} = resolveEnvOptions(config.env);
-
-            const filteredVars = filterEnvVars(vars, filter);
-
-            const key = generateKey([config.app, ...Object.keys(filteredVars)].join("-"));
+            const {filter} = resolveEnvOptions(config.env);
 
-            const data = crypt ? encryptData(filteredVars, key) : filteredVars;
+            const data = filterEnvVars(vars, filter);
 
             return {
                 plugins: [
                     new DefinePlugin({
-                        __ADNBN_ENV_CRYPTO_KEY__: JSON.stringify(key),
                         "process.env": JSON.stringify(data),
                     }),
                 ],

src/cli/plugins/dotenv/utils.test.ts

@@ -1,5 +1,5 @@
 import {filterEnvVars, resolveEnvOptions} from "./utils";
-import {ReservedEnvKeys} from "../../../types/env";
+import {EnvReservedKeys} from "../../../types/env";
 
 const baseVars = {
     APP: "myapp",
@@ -38,9 +38,9 @@ describe("dotenv utils - filterEnvVars & resolveEnvOptions", () => {
         });
     });
 
-    test("object with filter and crypt true - filter selection plus crypt flag detection", () => {
+    test("object with filter true - filter selection flag detection", () => {
         const option = {filter: "PUBLIC_", crypt: true} as const;
-        const {filter, crypt} = resolveEnvOptions(option);
+        const {filter} = resolveEnvOptions(option);
         const filtered = filterEnvVars(baseVars, filter);
         expect(filtered).toEqual({
             APP: baseVars.APP,
@@ -50,8 +50,6 @@ describe("dotenv utils - filterEnvVars & resolveEnvOptions", () => {
             PUBLIC_API_URL: baseVars.PUBLIC_API_URL,
             PUBLIC_FEATURE: baseVars.PUBLIC_FEATURE,
         });
-
-        expect(crypt).toBe(true);
     });
 
     test("empty string filter results in all keys", () => {
@@ -71,7 +69,7 @@ describe("dotenv utils - filterEnvVars & resolveEnvOptions", () => {
         const {filter} = resolveEnvOptions(() => false);
         const filtered = filterEnvVars(baseVars, filter);
         const expected: any = {};
-        for (const key of ReservedEnvKeys) expected[key] = (baseVars as any)[key];
+        for (const key of EnvReservedKeys) expected[key] = (baseVars as any)[key];
         expect(filtered).toEqual(expected);
     });
 

src/cli/plugins/dotenv/utils.ts

@@ -1,25 +1,23 @@
 import _ from "lodash";
-import {EnvFilterFunction, EnvFilterOptions, EnvFilterVariant, ReservedEnvKeys} from "@typing/env";
+import {EnvFilterFunction, EnvFilterOptions, EnvFilterVariant, EnvReservedKeys} from "@typing/env";
 
 export type EnvOption = EnvFilterVariant | Partial<EnvFilterOptions>;
 
-export const resolveEnvOptions = (option?: EnvOption): {filter: EnvFilterFunction; crypt: boolean} => {
+export const resolveEnvOptions = (option?: EnvOption): {filter: EnvFilterFunction} => {
     let userFilter: EnvFilterVariant | undefined;
-    let crypt: boolean = false;
 
     if (_.isString(option)) {
         userFilter = option;
     } else if (_.isFunction(option)) {
         userFilter = option;
     } else if (option && _.isObject(option)) {
-        const {filter: f, crypt: c} = option as Partial<EnvFilterOptions>;
+        const {filter: f} = option as Partial<EnvFilterOptions>;
 
         userFilter = f;
-        crypt = Boolean(c);
     }
 
     const filter = (key: string): boolean => {
-        if (ReservedEnvKeys.has(key)) {
+        if (EnvReservedKeys.has(key)) {
             return true;
         }
 
@@ -34,7 +32,7 @@ export const resolveEnvOptions = (option?: EnvOption): {filter: EnvFilterFunctio
         return true;
     };
 
-    return {filter, crypt};
+    return {filter};
 };
 
 export const filterEnvVars = <T extends Record<string, any>>(vars: T, filter: EnvFilterFunction): Partial<T> => {

src/cli/plugins/index.ts

@@ -1,21 +1,21 @@
-export {default as assetPlugin} from "./asset";
-export {default as bundlerPlugin} from "./bundler";
-export {default as backgroundPlugin} from "./background";
-export {default as contentPlugin} from "./content";
-export {default as dotenvPlugin} from "./dotenv";
-export {default as htmlPlugin} from "./html";
-export {default as optimizationPlugin} from "./optimization";
-export {default as outputPlugin} from "./output";
-export {default as iconPlugin} from "./icon";
-export {default as localePlugin} from "./locale";
-export {default as metaPlugin} from "./meta";
-export {default as offscreenPlugin} from "./offscreen";
-export {default as pagePlugin} from "./page";
-export {default as popupPlugin} from "./popup";
-export {default as publicPlugin} from "./public";
-export {default as sidebarPlugin} from "./sidebar";
-export {default as typescriptPlugin, TypescriptConfig, FileBuilder, VendorDeclaration} from "./typescript";
-export {default as reactPlugin} from "./react";
-export {default as stylePlugin} from "./style";
-export {default as viewPlugin} from "./view";
-export {default as versionPlugin} from "./version";
+export {default as pluginAsset} from "./asset";
+export {default as pluginBundler} from "./bundler";
+export {default as pluginBackground} from "./background";
+export {default as pluginContent} from "./content";
+export {default as pluginDotenv} from "./dotenv";
+export {default as pluginHtml} from "./html";
+export {default as pluginOptimization} from "./optimization";
+export {default as pluginOutput} from "./output";
+export {default as pluginIcon} from "./icon";
+export {default as pluginLocale} from "./locale";
+export {default as pluginMeta} from "./meta";
+export {default as pluginOffscreen} from "./offscreen";
+export {default as pluginPage} from "./page";
+export {default as pluginPopup} from "./popup";
+export {default as pluginPublic} from "./public";
+export {default as pluginSidebar} from "./sidebar";
+export {default as pluginTypescript, TypescriptConfig, FileBuilder, VendorDeclaration} from "./typescript";
+export {default as pluginReact} from "./react";
+export {default as pluginStyle} from "./style";
+export {default as pluginView} from "./view";
+export {default as pluginVersion} from "./version";

src/cli/plugins/meta/AbstractMeta.ts

@@ -4,7 +4,7 @@ import {getEnv} from "@main/env";
 
 import type {ReadonlyConfig} from "@typing/config";
 
-export default abstract class AbstractMeta<V extends string = string> {
+export default abstract class AbstractMeta<V = string> {
     public static value<T extends AbstractMeta<any>>(
         this: new (config: ReadonlyConfig) => T,
         config: ReadonlyConfig
@@ -19,22 +19,22 @@ export default abstract class AbstractMeta<V extends string = string> {
     public getResolved(): V | undefined {
         const value = this.getValue();
 
-        let resolved = _.isFunction(value) ? value() : value;
+        const resolved = _.isFunction(value) ? value() : value;
 
         if (this.isValid(resolved)) {
             return resolved;
         }
 
         if (_.isString(resolved)) {
-            resolved = getEnv(resolved);
+            const valueFromEnv = getEnv(resolved);
 
-            if (this.isValid(resolved)) {
-                return resolved;
+            if (this.isValid(valueFromEnv)) {
+                return valueFromEnv;
             }
         }
     }
 
-    protected isValid(value?: V): boolean {
+    protected isValid(value?: unknown): value is V {
         return true;
     }
 }