pushing some last WIP changes before deprecation

still doesnt work though

.prettierrc

@@ -3,6 +3,7 @@
     "singleQuote": false,
     "semi": true,
     "bracketSpacing": true,
+    "trailingComma": "none",
     "overrides": [
         {
             "files": "*.js",
@@ -11,4 +12,4 @@
             }
         }
     ]
-}
+}

babel.config.json

@@ -0,0 +1,3 @@
+{
+    "presets": ["@babel/preset-flow", "@babel/preset-react"]
+}

build.mjs

@@ -0,0 +1,22 @@
+import esbuild from "esbuild";
+import babel from "esbuild-plugin-babel";
+
+(async () => {
+    try {
+        await esbuild.build({
+            entryPoints: ["src/index.js"],
+            bundle: true,
+            minify: true,
+            format: "iife",
+            target: "es2021",
+            outfile: "dist/build.js",
+            plugins: [babel()]
+        });
+        console.log("Build succeeded!");
+        process.exit(0);
+    } catch (e) {
+        console.error(e);
+        console.log("Build failed!");
+        process.exit(1);
+    }
+})(); //IIFE to shutup lsp

package.json

@@ -1,26 +1,25 @@
 {
-  "name": "demoncord",
+    "name": "demoncord",
-  "version": "0.0.1-indev",
+    "version": "0.0.1-indev",
-  "description": "a devilesque client mod 😈",
+    "description": "a devilesque client mod 😈",
-  "main": "src/index.js",
+    "main": "src/index.js",
-  "scripts": {
+    "scripts": {
-    "build": "rollup --config rollup.config.js",
+        "build": "node build.mjs",
-    "flow": "flow"
+        "flow": "flow"
-  },
+    },
-  "author": "Drake",
+    "author": "Drake",
-  "license": "BSD-3-Clause",
+    "license": "BSD-3-Clause",
-  "devDependencies": {
+    "devDependencies": {
-    "@rollup/plugin-commonjs": "^21.0.1",
+        "@babel/core": "^7.17.8",
-    "@rollup/plugin-node-resolve": "^13.1.3",
+        "@babel/preset-flow": "^7.16.7",
-    "demonpatcher": "^0.1.0",
+        "@babel/preset-react": "^7.16.7",
-    "esbuild": "^0.14.11",
+        "esbuild": "^0.14.27",
-    "flow-bin": "^0.169.0",
+        "esbuild-plugin-babel": "^0.2.3",
-    "flow-remove-types": "^2.169.0",
+        "flow-bin": "^0.169.0",
-    "idb-keyval": "^6.0.3",
+        "flow-remove-types": "^2.174.1",
-    "rollup": "^2.63.0",
+        "idb-keyval": "^6.1.0",
-    "rollup-plugin-esbuild": "^4.8.2",
+        "react": "^17.0.2",
-    "rollup-plugin-flow": "^1.1.1",
+        "react-dom": "^17.0.2",
-    "rollup-plugin-uglify": "^6.0.4",
+        "simian": "^1.4.3"
-    "simian": "^1.4.3"
+    }
-  }
 }

rollup.config.js

@@ -1,14 +0,0 @@
-import flow from "rollup-plugin-flow";
-import { minify } from "rollup-plugin-esbuild";
-import { nodeResolve } from "@rollup/plugin-node-resolve";
-import commonjs from "@rollup/plugin-commonjs";
-import { defineConfig } from "rollup";
-
-export default defineConfig({
-    input: "src/index.js",
-    plugins: [flow(), commonjs(), nodeResolve(), minify()],
-    output: {
-        file: "dist/build.js",
-        format: "iife",
-    },
-});

shims/react.js

@@ -0,0 +1,3 @@
+import { React } from "../src/api/common.js";
+
+export { React };

src/api/commands.js

@@ -1,16 +1,18 @@
 // @flow
-
 const commandsSym = Symbol("__commands");
 
 function init(obj: Object) {
-    obj.demon[commandsSym] = {};
+	const { after }       = window.demon.require("patcher")
-    obj.demon.patcher.after(
+	const { findByProps } = window.demon.require("webpack")
+	window.demonCommands = {}
+	window.demonCommands[commandsSym] = {};
+    after(
         "sendMessage",
-        obj.demon.webpack.findByProps("sendMessage"),
+        findByProps("sendMessage"),
         (args, otherRes) => {
             let res;
-            for (const key of Reflect.ownKeys(obj.demon[commandsSym])) {
+            for (const key of Reflect.ownKeys(window.demonCommands[commandsSym])) {
-                let command = obj.demon[commandsSym][key];
+                let command = window.demonCommands[commandsSym][key];
                 if (args[1].content.split(" ")[0] === ">" + command.name) {
                     res = command.callback(args);
                     break;
@@ -28,16 +30,16 @@ function init(obj: Object) {
 // }
 function add(command: {
     name: string,
-    callback: (args: Array<any>) => string,
+    callback: (args: Array<any>) => string
 }): () => void {
     let sym = Symbol(command.name);
-    window.demon[commandsSym][sym] = command;
+    window.demonCommands[commandsSym][sym] = command;
     return () => {
-        delete window.demon[commandsSym][sym];
+        delete window.demonCommands[commandsSym][sym];
     };
 }
 
 export default {
     add: add,
-    init: init,
+    init: init
 };

src/api/common.js

@@ -1,18 +1,18 @@
 // @flow
-import webpack from "./webpack.js"
+import webpack from "./webpack.js";
 
 import * as idb from "idb-keyval";
 
-const common: {React: Object, ReactDOM: Object} = {
+const common: { React: Object, ReactDOM: Object } = {
-	React:    webpack.findByProps(
+    React: webpack.findByProps(
-		"__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED",
+        "__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED",
-		"createElement"
+        "createElement"
-	),
+    ),
-	ReactDOM: webpack.findByProps(
+    ReactDOM: webpack.findByProps(
-		"__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED",
+        "__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED",
-		"hydrate"
+        "hydrate"
-	),
+    ),
-	"idb_keyval": idb
+    idb_keyval: idb
-}
+};
 
 export default common;

src/api/css.js

@@ -0,0 +1,56 @@
+// @flow
+//TODO: proper typing
+//TODO: use webpack to find
+
+//TODO: funny sink code
+//(() => {
+//  const raw = findAll(
+//    (m) =>
+//      typeof m === "object" &&
+//      Object.values(m).length > 0 &&
+//      Object.values(m).every((v) => typeof v === "string")
+//  );
+//  const map = new Map();
+//  for (const m of raw)
+//    for (const [k, v] of Object.entries(m))
+//      if (map.has(k)) map.get(k).push(v);
+//      else map.set(k, [v]);
+//  return map;
+//})();
+function getAllClasses() {
+    return document.styleSheets[0].rules || document.styleSheets[0].cssRules;
+}
+
+function getClassListByName(className) {
+    const classes = getAllClasses();
+    return classes;
+}
+
+//how to define getters and setters on an object:
+//
+//Object.defineProperty(hello, "place", {
+//  set: (x) => {
+//    this.oldPlace = this.place;
+//    this.place = x;
+//  },
+//  get: (x) => {
+//    console.log(
+//      "Current place: " + this.place + "\nPlace before this: " + this.oldPlace
+//    );
+//    return this.place;
+//  },
+//});
+
+function getProxyObj(classes) {}
+
+function init(obj: Object) {
+    obj.demon.css = {
+        classes: {
+            get: (className) => {}
+        }
+    };
+}
+
+export default {
+    init
+};

src/api/plugins.js

@@ -1,8 +1,9 @@
 // @flow
 import { get, set } from "idb-keyval";
 import logger from "./utils/logger.js";
-import settingsInj from "./settingsInj.js";
+import settingsInj from "./settings/settingsInj.js";
 
+window.demonPlugins = {} //TODO: jank
 const pluginsSym = Symbol("__plugins");
 
 async function init(obj: Object): Promise<boolean> {
@@ -22,13 +23,15 @@ async function init(obj: Object): Promise<boolean> {
     return true;
 }
 
-async function addPlugin(iife: string, metadata: Object): Promise<boolean> {
+async function addPlugin(iife: string): Promise<boolean> {
     // expected metadata: {name: "name", desc: "description", author: "author"}
+    const exports: Object = (0, eval)(iife);
+    const metadata: Object = exports.metadata;
     const obj: Object = {
         // whether the plugin is started or stopped isn't going to be stored in the iDB, so it can be accessed more easily by all components
         metadata: metadata,
         iife: iife,
-        enabled: false, // should plugins be enabled by default? not sure
+        enabled: false // should plugins be enabled by default? not sure
     };
     const globalSettings: Object = await get("demoncord");
     /*try {
@@ -67,6 +70,9 @@ async function startPlugin(name: string): Promise<boolean> {
         const exports: Object = (0, eval)(plug.iife);
         const onStart: (ctx: Object) => void = exports.onStart;
         let ctx = {}; // ctx is how you're going to store things that need to be accessed in both onStart and onStop. dumb, i know
+        if (plug.metadata.cumcord) {
+            ctx.cumcord = window.demon; //TODO: explicit cumcord compat layer.
+        }
         onStart(ctx);
         if (exports.settings)
             settingsInj.registerSettingsEntry(
@@ -75,7 +81,7 @@ async function startPlugin(name: string): Promise<boolean> {
                 exports.settings
             );
         logger.log(`Started ${name}!`, ["Plugins"]);
-        window.demon[pluginsSym][name] = { status: 1, ctx: ctx };
+        window.demonPlugins[pluginsSym][name] = { status: 1, ctx: ctx };
         return true;
     }
 }
@@ -84,7 +90,7 @@ async function stopPlugin(name: string): Promise<boolean> {
     const globalSettings = await get("demoncord");
     if (globalSettings["plugin"][name] === undefined) {
         logger.error("Cannot stop non-existant or non-running plugin!", [
-            "Plugins",
+            "Plugins"
         ]);
         return false;
     } else {
@@ -92,7 +98,7 @@ async function stopPlugin(name: string): Promise<boolean> {
         const plug = globalSettings["plugin"][name];
         const exports: Object = (0, eval)(plug.iife);
         const onStop: (ctx: Object) => void = exports.onStop;
-        onStop(window.demon[pluginsSym][name].ctx);
+        onStop(window.demonPlugins[pluginsSym][name].ctx);
         settingsInj.unregisterSettingsEntry("DEMON_PLUGIN_SETTINGS_" + name);
         logger.log(`Stopped ${name}!`, ["Plugins"]);
         return true;
@@ -118,5 +124,5 @@ export default {
     delPlugin,
     startPlugin,
     stopPlugin,
-    togglePlugin,
+    togglePlugin
 };

src/api/settings/components/card/card.jsx

@@ -0,0 +1,83 @@
+// @flow
+/*import { make, join } from '@modules/styles';
+import SettingsAPI from '@modules/apis/Settings';
+import Manager, { modules } from '@modules/manager';
+
+const styles = make('pluginCard');
+const Settings = SettingsAPI.create('modules');
+
+const { Filters } = Webpack;
+
+const [
+  SwitchItem,
+  { Heading },
+  SettingsIcon,
+] = Webpack.bulk(
+  Filters.byDisplayName('SwitchItem'),
+  Filters.byProps('Heading'),
+  Filters.byDisplayName('Gear'),
+);*/
+
+import common from "../../../common";
+import webpack from "../../../webpack";
+const React = common.React;
+
+const SwitchItem = webpack.findByDisplayName("SwitchItem");
+const { Heading } = webpack.findByProps("Heading");
+const SettingsIcon = webpack.findByDisplayName("Gear");
+
+function useDidUpdateEffect(effect, deps?) {
+    const didMountRef = React.useRef(false);
+
+    React.useEffect(() => {
+        if (didMountRef.current) return effect();
+
+        // else set didMount to true
+        didMountRef.current = true;
+    }, deps);
+}
+
+export default (module: {
+    file: string,
+    name: string,
+    version: string,
+    description: string,
+    setPage: React.Dispatch<React.SetStateAction<string>>
+}) => {
+    return (
+        <div className={styles.container}>
+            <div className={styles.headerContainer}>
+                <div className={styles.textContainer}>
+                    <Heading
+                        level={2}
+                        lineClamp={1}
+                        className={styles.text}
+                        variant="heading-lg/medium"
+                    >
+                        {module.name}
+                    </Heading>
+                    <div className={styles.version}>{module.version}</div>
+                </div>
+                <SwitchItem
+                    hideBorder
+                    value={enabled}
+                    onChange={setEnabled}
+                    className={styles.switch}
+                />
+                <div
+                    className={join(
+                        styles.settings,
+                        !enabled || !settings ? styles.settingsDisabled : false
+                    )}
+                >
+                    <SettingsIcon
+                        onClick={() =>
+                            enabled && settings && setPage(module.file)
+                        }
+                    />
+                </div>
+            </div>
+            <div className={styles.description}>{module.description}</div>
+        </div>
+    );
+};

src/api/settings/components/settings.jsx

@@ -0,0 +1,16 @@
+// @flow
+import webpack from "../../webpack.js";
+import common from "../../common.js";
+const React = common.React;
+
+const FormTitle = webpack.findByDisplayName("FormTitle");
+const FormDivider = webpack.findByDisplayName("FormDivider");
+const FormSection = webpack.findByDisplayName("FormSection");
+
+export default function (): any {
+    return (
+        <FormSection>
+            <FormTitle tag="h1">Demoncord Settings</FormTitle>
+        </FormSection>
+    );
+}

src/api/settings/settings.js

@@ -0,0 +1,17 @@
+// @flow
+import tmp from "./settingsInj.js";
+const registerSettingsEntry = tmp.registerSettingsEntry;
+import common from "../common.js";
+const React = common.React;
+
+import Settings from "./components/settings.jsx";
+
+function init() {
+    console.log(Settings);
+    console.log(Settings());
+    registerSettingsEntry("General Settings", undefined, Settings);
+}
+
+export default {
+    init
+};

src/api/settings/settingsInj.js

@@ -1,38 +1,45 @@
 // @flow
 
-import webpack from "./webpack";
+import webpack from "../webpack.js";
+import common from "../common.js";
+
+const React = common.React;
 
 const settingsSym = Symbol("__settings");
 
+window.demonSettings = {};
+
 // super secret value that shouldnt be exposed, used internally to avoid section conflicts and the like
 const ovrwrtSctnSym: symbol = Symbol("__overwriteSection");
 
-const settingsView = webpack.find(
+const settingsView = webpack.findByDisplayName("SettingsView");
-    (m) => m.default && m.default.displayName === "SettingsView"
-);
 
 type getPredicateSectionsEntry =
     | {
           section: "HEADER",
-          label: string,
+          label: string
       }
     | {
-          section: "DIVIDER",
+          section: "DIVIDER"
       }
     | {
           section: string,
           label: string,
-          component: Function,
+          component: Function
       };
 
 function patch(args: mixed, ret: getPredicateSectionsEntry[]) {
-    const processedEntries = window.demon[settingsSym].entries.map((e) => ({
+    const processedEntries = window.demonSettings[settingsSym].entries.map(
-        section:
+        (e) => ({
-            (e[ovrwrtSctnSym] ? e[ovrwrtSctnSym] : "DEMON_SETTINGS_LOADER_") +
+            section: (e[ovrwrtSctnSym] ?? "DEMON_SETTINGS_LOADER_") + e.name,
-            e.name,
+            label: e.name,
-        label: e.name,
+            element: e.component
-        element: e.component,
+        })
-    }));
+    );
+
+    processedEntries.map((e) => {
+        console.log(e);
+    });
 
     const injectionIndex =
         2 + ret.findIndex((section) => section.section === "Game Activity");
@@ -47,29 +54,28 @@ function patch(args: mixed, ret: getPredicateSectionsEntry[]) {
 }
 
 function init() {
-    window.demon[settingsSym] = {
+    const patcher = window.demon.require("patcher");
-        patch: window.demon.patcher.after(
+    window.demonSettings[settingsSym] = {
+        patch: patcher.after(
             "getPredicateSections",
             settingsView.default.prototype,
             patch
         ),
-        entries: [],
+        entries: []
     };
 
     // debug
-    window.__demontemp__UnpatchSettingsInj = unInit();
+    //window.__demontemp__UnpatchSettingsInj = unInit();
 }
 
 function unInit() {
-    window.demon[settingsSym].patch();
+    window.demonSettings[settingsSym].patch();
-    delete window.demon[settingsSym];
+    delete window.demonSettings[settingsSym];
 }
 
 function unregisterSettingsEntry(name: string) {
-    let s = window.demon[settingsSym];
+    let s = window.demonSettings[settingsSym];
-    s.entries = s.entries.filter(
+    s.entries = s.entries.filter((e) => (e[ovrwrtSctnSym] ?? e.name) !== name);
-        (e) => (e[ovrwrtSctnSym] ? e[ovrwrtSctnSym] : e.name) !== name
-    );
 }
 
 function registerSettingsEntry(
@@ -79,7 +85,9 @@ function registerSettingsEntry(
 ): () => void {
     let entry: { [symbol | string]: any } = { name, component };
     if (section) entry[ovrwrtSctnSym] = section;
-    window.demon[settingsSym].entries.push(entry);
+    //entry.component.type = entry.component.type.default
+    console.log(entry);
+    window.demonSettings[settingsSym].entries.push(entry);
     return () => unregisterSettingsEntry(name);
 }
 
@@ -88,5 +96,5 @@ export default {
     unInit,
     registerSettingsEntry,
     unregisterSettingsEntry,
-    ovrwrtSctnSymm: ovrwrtSctnSym,
+    ovrwrtSctnSymm: ovrwrtSctnSym
 };

src/api/utils/logger.js

@@ -79,5 +79,5 @@ export default {
     warn,
     error,
     trace,
-    group,
+    group
 };

src/api/webpack.js

@@ -1,60 +1,69 @@
 // @flow
-type ModuleType = Object/* { [symbol]: any } */;
+type ModuleType = Object /* { [symbol]: any } */;
 type FilterFunc = (module: ModuleType) => boolean;
 
 function getModules(): any {
-  let modules: { c: mixed[] } = {};
+    let modules: { c: mixed[] } = {};
 
-  window.webpackChunkdiscord_app.push([
+    window.webpackChunkdiscord_app.push([
-    [Math.random().toString(36)],
+        [Math.random().toString(36)],
-    {},
+        {},
-    (e) => {
+        (e) => {
-      modules = e;
+            modules = e;
-    },
+        }
-  ]);
+    ]);
 
-  return modules.c;
+    return modules.c;
 }
 
 function filter(filter: FilterFunc, moduleList: any): Array<Object> {
-  let modules: Array<mixed[]> = [];
+    let modules: Array<mixed[]> = [];
-  for (const mod in moduleList) {
+    for (const mod in moduleList) {
-    const module = moduleList[mod].exports;
+        const module = moduleList[mod].exports;
-    if (module) {
+        if (module) {
-      if (module.default && module.__esModule && filter(module.default)) {
+            if (module.default && module.__esModule && filter(module.default)) {
-        modules.push(module.default);
+                modules.push(module.default);
-      } else if (filter(module)) {
+            } else if (filter(module)) {
-        modules.push(module);
+                modules.push(module);
-      }
+            }
+        }
     }
-  }
+    return modules;
-  return modules;
 }
 
 type WebpackModules = {
-  modules: () => any,
+    modules: () => any,
-  filter: (filter: FilterFunc, moduleList: any) => Object[],
+    filter: (filter: FilterFunc, moduleList: any) => Object[],
-  find: (filter: FilterFunc) => Object,
+    find: (filter: FilterFunc) => Object,
-  findAll: (filter: FilterFunc) => Object[],
+    findAll: (filter: FilterFunc) => Object[],
-  findByProps: (...props: string[]) => Object,
+    findByProps: (...props: string[]) => Object,
-  findByPropsAll: (...props: string[]) => Object[],
+    findByPropsAll: (...props: string[]) => Object[],
+    findByDisplayName: (prop: string) => Object[],
+    reloadModules: () => void
 };
 
 let webpack: WebpackModules = {
-  modules: getModules(),
+    modules: getModules(),
-  filter: filter,
+    filter: filter,
-  find: (filter: FilterFunc) => webpack.filter(filter, webpack.modules)[0],
+    find: (filter: FilterFunc) => webpack.filter(filter, webpack.modules)[0],
-  findAll: (filter: FilterFunc) => webpack.filter(filter, webpack.modules),
+    findAll: (filter: FilterFunc) => webpack.filter(filter, webpack.modules),
-  findByProps: (...props: Array<string>) => {
+    findByProps: (...props: Array<string>) => {
-    return webpack.find((module) => {
+        return webpack.find((module) => {
-      return props.every((prop) => module[prop] !== undefined);
+            return props.every((prop) => module[prop] !== undefined);
-    });
+        });
-  },
+    },
-  findByPropsAll: (...props: Array<string>) => {
+    findByPropsAll: (...props: Array<string>) => {
-    return webpack.findAll((module) =>
+        return webpack.findAll((module) =>
-      props.every((prop) => module[prop] !== undefined)
+            props.every((prop) => module[prop] !== undefined)
-    );
+        );
-  },
+    },
+    findByDisplayName: (prop: string) => {
+        return webpack.find((m) => m?.default?.displayName === prop);
+    },
+    reloadModules: () => {
+        //NOTE: i have no idea why this could even feasibly need to be used, but i'm adding it anyways
+        webpack.modules = getModules();
+    }
 };
 
 export default webpack;

src/index.js

@@ -1,7 +1,34 @@
-import init from "./init.js"
+// @flow
+import init from "./init.js";
+import settingsInj from "./api/settings/settingsInj";
+import commands from "./api/commands";
 
-if (window.demon) {
+const obj = {};
-	delete window.demon; // this is a very good idea
+
+init(obj);
+
+window.demon = {};
+
+function isAllowed(mod: String): boolean {
+    //TODO: permissions checking
+    return true;
 }
 
-init(window)
+window.demon.require = (mod: String): Object => {
+    if (!isAllowed(mod)) {
+        throw new Error("Not allowed!"); //TODO: make this not irrepairably error out
+    }
+    const mods = mod.split("/");
+    let res = obj.demon;
+    mods.forEach((m) => {
+        if (m in res) {
+            res = res[m];
+        } else {
+            throw new Error("Module does not exist!");
+        }
+    });
+    return res;
+};
+
+settingsInj.init();
+commands.init(obj);

src/init.js

@@ -2,9 +2,10 @@
 import Patcher from "simian";
 import webpack from "./api/webpack";
 import common from "./api/common";
-import commands from "./api/commands";
 import plugins from "./api/plugins";
-import settingsInj from "./api/settingsInj";
+import settings from "./api/settings/settings";
+import css from "./api/css";
+import commands from "./api/commands";
 
 async function init(obj: Object): Promise<void> {
     const patcher = new Patcher();
@@ -30,20 +31,17 @@ async function init(obj: Object): Promise<void> {
             },
             before: patcher.before,
             instead: patcher.instead,
-            after: patcher.after,
+            after: patcher.after
         },
         webpack,
         common,
         commands: {
-            add: commands.add,
+            add: commands.add
         },
-        __DO_NOT_USE_OR_YOU_WILL_BE_FIRED_UNTO_THE_DEPTHS_OF_HELL: {
+		plugins
-            plugins,
-        }
     };
-    commands.init(obj);
-    settingsInj.init();
     plugins.init(obj);
+    css.init(obj);
 }
 
 export default init;