commit cba05a3de85fdfa1301bba46baf42849a6ca569b · notnite.com/moonlight

+54 -2

packages/core-extensions/src/markdown/index.ts

···

       1
       1
       -
       import { Patch } from "@moonlight-mod/types";

     

       1
       1
       +
       import { ExtensionWebpackModule, Patch } from "@moonlight-mod/types";

     

       2
       2
        
       

     

       3
       3
       -
       export const patches: Patch[] = [];

     

       3
       3
       +
       export const patches: Patch[] = [

     

       4
       4
       +
         {

     

       5
       5
       +
           find: "/^(¯\\\\_\\(ツ\\)_\\/¯)/.exec",

     

       6
       6
       +
           replace: [

     

       7
       7
       +
             {

     

       8
       8
       +
               match: /={newline:(.+?)},(.{1,2})=\(0,/,

     

       9
       9
       +
               replacement: (_, rules, RULES) =>

     

       10
       10
       +
                 `=require("markdown_markdown")._addRules({newline:${rules}}),${RULES}=(0,`

     

       11
       11
       +
             },

     

       12
       12
       +
             {

     

       13
       13
       +
               match: /(?<=var (.{1,2})={RULES:.+?})/,

     

       14
       14
       +
               replacement: (_, rulesets) =>

     

       15
       15
       +
                 `;require("markdown_markdown")._applyRulesetBlacklist(${rulesets});`

     

       16
       16
       +
             }

     

       17
       17
       +
           ]

     

       18
       18
       +
         },

     

       19
       19
       +
         {

     

       20
       20
       +
           find: "then you probably need to add it to this file so that the rich chat box understands it.",

     

       21
       21
       +
           replace: [

     

       22
       22
       +
             {

     

       23
       23
       +
               match: /(.)={link:{(.+?)},(.)=new Set/,

     

       24
       24
       +
               replacement: (_, rulesDef, rules, syntaxBefore) =>

     

       25
       25
       +
                 `__slateRules,${rulesDef}=__slateRules=require("markdown_markdown")._addSlateRules({link:{${rules}}),${syntaxBefore}=new Set`

     

       26
       26
       +
             },

     

       27
       27
       +
             {

     

       28
       28
       +
               match:

     

       29
       29
       +
                 /(originalMatch:.}=(.);)(.+?)case"emoticon":(return .+?;)(.+?)case"link":{(.+?)}default:/,

     

       30
       30
       +
               replacement: (

     

       31
       31
       +
                 _,

     

       32
       32
       +
                 start,

     

       33
       33
       +
                 rule,

     

       34
       34
       +
                 body,

     

       35
       35
       +
                 plaintextReturn,

     

       36
       36
       +
                 otherRules,

     

       37
       37
       +
                 inlineStyleBody

     

       38
       38
       +
               ) =>

     

       39
       39
       +
                 `${start}if(${rule}.type.startsWith("__moonlight_")){if(__slateRules[${rule}.type].type=="inlineStyle"){${inlineStyleBody}}else{${plaintextReturn}}}${body}case"emoticon":${plaintextReturn}${otherRules}case"link":{${inlineStyleBody}}default:`

     

       40
       40
       +
             }

     

       41
       41
       +
           ]

     

       42
       42
       +
         },

     

       43
       43
       +
         {

     

       44
       44
       +
           find: '"Slate: Unknown decoration attribute: "',

     

       45
       45
       +
           replace: {

     

       46
       46
       +
             match: /=({strong:.+?});/,

     

       47
       47
       +
             replacement: (_, rules) =>

     

       48
       48
       +
               `=require("markdown_markdown")._addSlateDecorators(${rules});`

     

       49
       49
       +
           }

     

       50
       50
       +
         }

     

       51
       51
       +
       ];

     

       52
       52
       +
       

     

       53
       53
       +
       export const webpackModules: Record<string, ExtensionWebpackModule> = {

     

       54
       54
       +
         markdown: {}

     

       55
       55
       +
       };

-94

packages/core-extensions/src/markdown/types.ts

···

       1
       1
       -
       // {{{ simple-markdown

     

       2
       2
       -
       

     

       3
       3
       -
       type SingleASTNode = {

     

       4
       4
       -
         type: string;

     

       5
       5
       -
         [key: string]: any;

     

       6
       6
       -
       };

     

       7
       7
       -
       

     

       8
       8
       -
       type UnTypedASTNode = {

     

       9
       9
       -
         [key: string]: any;

     

       10
       10
       -
       };

     

       11
       11
       -
       

     

       12
       12
       -
       type ASTNode = SingleASTNode | Array<SingleASTNode>;

     

       13
       13
       -
       

     

       14
       14
       -
       type Parser = (

     

       15
       15
       -
         source: string,

     

       16
       16
       -
         state?: State | null | undefined

     

       17
       17
       -
       ) => Array<SingleASTNode>;

     

       18
       18
       -
       

     

       19
       19
       -
       type ParseFunction = (

     

       20
       20
       -
         capture: Capture,

     

       21
       21
       -
         nestedParse: Parser,

     

       22
       22
       -
         state: State

     

       23
       23
       -
       ) => UnTypedASTNode | ASTNode;

     

       24
       24
       -
       

     

       25
       25
       -
       type Capture =

     

       26
       26
       -
         | (Array<string> & {

     

       27
       27
       -
             index: number;

     

       28
       28
       -
           })

     

       29
       29
       -
         | (Array<string> & {

     

       30
       30
       -
             index?: number;

     

       31
       31
       -
           });

     

       32
       32
       -
       

     

       33
       33
       -
       type State = {

     

       34
       34
       -
         key?: string | number | undefined;

     

       35
       35
       -
         inline?: boolean | null | undefined;

     

       36
       36
       -
         [key: string]: any;

     

       37
       37
       -
       };

     

       38
       38
       -
       

     

       39
       39
       -
       type MatchFunction = {

     

       40
       40
       -
         regex?: RegExp;

     

       41
       41
       -
       } & ((

     

       42
       42
       -
         source: string,

     

       43
       43
       -
         state: State,

     

       44
       44
       -
         prevCapture: string

     

       45
       45
       -
       ) => Capture | null | undefined);

     

       46
       46
       -
       

     

       47
       47
       -
       type Output<Result> = (

     

       48
       48
       -
         node: ASTNode,

     

       49
       49
       -
         state?: State | null | undefined

     

       50
       50
       -
       ) => Result;

     

       51
       51
       -
       

     

       52
       52
       -
       type ArrayNodeOutput<Result> = (

     

       53
       53
       -
         node: Array<SingleASTNode>,

     

       54
       54
       -
         nestedOutput: Output<Result>,

     

       55
       55
       -
         state: State

     

       56
       56
       -
       ) => Result;

     

       57
       57
       -
       

     

       58
       58
       -
       // }}}

     

       59
       59
       -
       

     

       60
       60
       -
       export type ValidFlags = "g" | "i" | "m" | "s" | "u" | "y" | undefined;

     

       61
       61
       -
       

     

       62
       62
       -
       export type MarkdownRule = {

     

       63
       63
       -
         order: number;

     

       64
       64
       -
         match: MatchFunction;

     

       65
       65
       -
         parse: ParseFunction;

     

       66
       66
       -
         react: ArrayNodeOutput<React.ReactNode>;

     

       67
       67
       -
       };

     

       68
       68
       -
       

     

       69
       69
       -
       export type SlateRule =

     

       70
       70
       -
         | {

     

       71
       71
       -
             type: "skip";

     

       72
       72
       -
           }

     

       73
       73
       -
         | {

     

       74
       74
       -
             type: "verbatim";

     

       75
       75
       -
           }

     

       76
       76
       -
         | {

     

       77
       77
       -
             type: "inlineObject";

     

       78
       78
       -
           }

     

       79
       79
       -
         | {

     

       80
       80
       -
             type: "inlineStyle";

     

       81
       81
       -
             before: string;

     

       82
       82
       -
             after: string;

     

       83
       83
       -
           };

     

       84
       84
       -
       

     

       85
       85
       -
       export type Ruleset =

     

       86
       86
       -
         | "CHANNEL_TOPIC_RULES"

     

       87
       87
       -
         | "VOICE_CHANNEL_STATUS_RULES"

     

       88
       88
       -
         | "EMBED_TITLE_RULES"

     

       89
       89
       -
         | "INLINE_REPLY_RULES"

     

       90
       90
       -
         | "GUILD_VERIFICATION_FORM_RULES"

     

       91
       91
       -
         | "GUILD_EVENT_RULES"

     

       92
       92
       -
         | "PROFILE_BIO_RULES"

     

       93
       93
       -
         | "AUTO_MODERATION_SYSTEM_MESSAGE_RULES"

     

       94
       94
       -
         | "NATIVE_SEARCH_RESULT_LINK_RULES";

+68 -3

packages/core-extensions/src/markdown/webpackModules/markdown.ts

···

       1
       1
       -
       import { MarkdownRule, Ruleset, SlateRule } from "../types";

     

       1
       1
       +
       /* eslint-disable no-console */

     

       2
       2
       +
       import {

     

       3
       3
       +
         MarkdownRule,

     

       4
       4
       +
         Ruleset,

     

       5
       5
       +
         SlateRule

     

       6
       6
       +
       } from "@moonlight-mod/types/coreExtensions/markdown";

     

       2
       7
        
       

     

       3
       3
       -
       export const rules: Record<string, MarkdownRule> = {};

     

       4
       4
       -
       export const slateRules: Record<string, SlateRule> = {};

     

       8
       8
       +
       export const rules: Record<

     

       9
       9
       +
         string,

     

       10
       10
       +
         (rules: Record<string, MarkdownRule>) => MarkdownRule

     

       11
       11
       +
       > = {};

     

       12
       12
       +
       export const slateRules: Record<

     

       13
       13
       +
         string,

     

       14
       14
       +
         (rules: Record<string, SlateRule>) => SlateRule

     

       15
       15
       +
       > = {};

     

       5
       16
        
       export const slateDecorators: Record<string, string> = {};

     

       6
       17
        
       export const ruleBlacklists: Record<Ruleset, Record<string, boolean>> = {

     

       18
       18
       +
         RULES: {},

     

       7
       19
        
         CHANNEL_TOPIC_RULES: {},

     

       8
       20
        
         VOICE_CHANNEL_STATUS_RULES: {},

     

       9
       21
        
         EMBED_TITLE_RULES: {},

     
···

       14
       26
        
         AUTO_MODERATION_SYSTEM_MESSAGE_RULES: {},

     

       15
       27
        
         NATIVE_SEARCH_RESULT_LINK_RULES: {}

     

       16
       28
        
       };

     

       29
       29
       +
       

     

       30
       30
       +
       export function addRule(

     

       31
       31
       +
         name: string,

     

       32
       32
       +
         markdown: (rules: Record<string, MarkdownRule>) => MarkdownRule,

     

       33
       33
       +
         slate: (rules: Record<string, SlateRule>) => SlateRule,

     

       34
       34
       +
         decorator?: string

     

       35
       35
       +
       ) {

     

       36
       36
       +
         rules[name] = markdown;

     

       37
       37
       +
         slateRules[name] = slate;

     

       38
       38
       +
         if (decorator != null) slateDecorators[name] = decorator;

     

       39
       39
       +
       }

     

       40
       40
       +
       

     

       41
       41
       +
       export function blacklistFromRuleset(ruleset: Ruleset, name: string) {

     

       42
       42
       +
         if (ruleBlacklists[ruleset] == null) ruleBlacklists[ruleset] = {};

     

       43
       43
       +
         ruleBlacklists[ruleset][name] = true;

     

       44
       44
       +
       }

     

       45
       45
       +
       

     

       46
       46
       +
       export function _addRules(originalRules: Record<string, MarkdownRule>) {

     

       47
       47
       +
         for (const name in rules) {

     

       48
       48
       +
           originalRules["__moonlight_" + name] = rules[name](originalRules);

     

       49
       49
       +
         }

     

       50
       50
       +
       

     

       51
       51
       +
         return originalRules;

     

       52
       52
       +
       }

     

       53
       53
       +
       

     

       54
       54
       +
       export function _addSlateRules(originalRules: Record<string, SlateRule>) {

     

       55
       55
       +
         for (const name in slateRules) {

     

       56
       56
       +
           originalRules["__moonlight_" + name] = slateRules[name](originalRules);

     

       57
       57
       +
         }

     

       58
       58
       +
       

     

       59
       59
       +
         return originalRules;

     

       60
       60
       +
       }

     

       61
       61
       +
       

     

       62
       62
       +
       export function _addSlateDecorators(originalRules: Record<string, string>) {

     

       63
       63
       +
         for (const name in slateDecorators) {

     

       64
       64
       +
           originalRules["__moonlight_" + name] = slateDecorators[name];

     

       65
       65
       +
         }

     

       66
       66
       +
       

     

       67
       67
       +
         return originalRules;

     

       68
       68
       +
       }

     

       69
       69
       +
       

     

       70
       70
       +
       export function _applyRulesetBlacklist(

     

       71
       71
       +
         rulesets: Record<Ruleset, Record<string, MarkdownRule>>

     

       72
       72
       +
       ) {

     

       73
       73
       +
         for (const ruleset of Object.keys(rulesets) as Ruleset[]) {

     

       74
       74
       +
           if (ruleset === "RULES") continue;

     

       75
       75
       +
       

     

       76
       76
       +
           const rules = rulesets[ruleset];

     

       77
       77
       +
           for (const rule in ruleBlacklists[ruleset] || {}) {

     

       78
       78
       +
             delete rules["__moonlight_" + rule];

     

       79
       79
       +
           }

     

       80
       80
       +
         }

     

       81
       81
       +
       }

packages/types/src/coreExtensions.ts

···

       65
       65
        
       export type CommonFlux = FluxDefault;

     

       66
       66
        
       export type CommonComponents = CommonComponents_; // lol

     

       67
       67
        
       export type CommonFluxDispatcher = Dispatcher<any>;

     

       68
       68
       +
       

     

       69
       69
       +
       export * as Markdown from "./coreExtensions/markdown";

+110

packages/types/src/coreExtensions/markdown.ts

···

       1
       1
       +
       // {{{ simple-markdown

     

       2
       2
       +
       

     

       3
       3
       +
       export type SingleASTNode = {

     

       4
       4
       +
         type: string;

     

       5
       5
       +
         [key: string]: any;

     

       6
       6
       +
       };

     

       7
       7
       +
       

     

       8
       8
       +
       export type UntypedASTNode = {

     

       9
       9
       +
         [key: string]: any;

     

       10
       10
       +
       };

     

       11
       11
       +
       

     

       12
       12
       +
       export type ASTNode = SingleASTNode | Array<SingleASTNode>;

     

       13
       13
       +
       

     

       14
       14
       +
       export type Parser = (

     

       15
       15
       +
         source: string,

     

       16
       16
       +
         state?: State | null | undefined

     

       17
       17
       +
       ) => Array<SingleASTNode>;

     

       18
       18
       +
       

     

       19
       19
       +
       export type ParseFunction = (

     

       20
       20
       +
         capture: Capture,

     

       21
       21
       +
         nestedParse: Parser,

     

       22
       22
       +
         state: State

     

       23
       23
       +
       ) => UntypedASTNode | ASTNode;

     

       24
       24
       +
       

     

       25
       25
       +
       export type Capture =

     

       26
       26
       +
         | (Array<string> & {

     

       27
       27
       +
             index: number;

     

       28
       28
       +
           })

     

       29
       29
       +
         | (Array<string> & {

     

       30
       30
       +
             index?: number;

     

       31
       31
       +
           });

     

       32
       32
       +
       

     

       33
       33
       +
       export type State = {

     

       34
       34
       +
         key?: string | number | undefined;

     

       35
       35
       +
         inline?: boolean | null | undefined;

     

       36
       36
       +
         [key: string]: any;

     

       37
       37
       +
       };

     

       38
       38
       +
       

     

       39
       39
       +
       export type MatchFunction = {

     

       40
       40
       +
         regex?: RegExp;

     

       41
       41
       +
       } & ((

     

       42
       42
       +
         source: string,

     

       43
       43
       +
         state: State,

     

       44
       44
       +
         prevCapture: string

     

       45
       45
       +
       ) => Capture | null | undefined);

     

       46
       46
       +
       

     

       47
       47
       +
       export type Output<Result> = (

     

       48
       48
       +
         node: ASTNode,

     

       49
       49
       +
         state?: State | null | undefined

     

       50
       50
       +
       ) => Result;

     

       51
       51
       +
       

     

       52
       52
       +
       export type SingleNodeOutput<Result> = (

     

       53
       53
       +
         node: SingleASTNode,

     

       54
       54
       +
         nestedOutput: Output<Result>,

     

       55
       55
       +
         state: State

     

       56
       56
       +
       ) => Result;

     

       57
       57
       +
       

     

       58
       58
       +
       // }}}

     

       59
       59
       +
       

     

       60
       60
       +
       export type ValidFlags = "g" | "i" | "m" | "s" | "u" | "y" | undefined;

     

       61
       61
       +
       

     

       62
       62
       +
       export type MarkdownRule = {

     

       63
       63
       +
         order: number;

     

       64
       64
       +
         match: MatchFunction;

     

       65
       65
       +
         parse: ParseFunction;

     

       66
       66
       +
         react: SingleNodeOutput<React.ReactNode>;

     

       67
       67
       +
       };

     

       68
       68
       +
       

     

       69
       69
       +
       export type SlateRule =

     

       70
       70
       +
         | {

     

       71
       71
       +
             type: "skip";

     

       72
       72
       +
           }

     

       73
       73
       +
         | {

     

       74
       74
       +
             type: "verbatim";

     

       75
       75
       +
           }

     

       76
       76
       +
         | {

     

       77
       77
       +
             type: "inlineObject";

     

       78
       78
       +
           }

     

       79
       79
       +
         | {

     

       80
       80
       +
             type: "inlineStyle";

     

       81
       81
       +
             before: string;

     

       82
       82
       +
             after: string;

     

       83
       83
       +
           };

     

       84
       84
       +
       

     

       85
       85
       +
       export type Ruleset =

     

       86
       86
       +
         | "RULES"

     

       87
       87
       +
         | "CHANNEL_TOPIC_RULES"

     

       88
       88
       +
         | "VOICE_CHANNEL_STATUS_RULES"

     

       89
       89
       +
         | "EMBED_TITLE_RULES"

     

       90
       90
       +
         | "INLINE_REPLY_RULES"

     

       91
       91
       +
         | "GUILD_VERIFICATION_FORM_RULES"

     

       92
       92
       +
         | "GUILD_EVENT_RULES"

     

       93
       93
       +
         | "PROFILE_BIO_RULES"

     

       94
       94
       +
         | "AUTO_MODERATION_SYSTEM_MESSAGE_RULES"

     

       95
       95
       +
         | "NATIVE_SEARCH_RESULT_LINK_RULES";

     

       96
       96
       +
       

     

       97
       97
       +
       export type Markdown = {

     

       98
       98
       +
         rules: Record<string, MarkdownRule>;

     

       99
       99
       +
         slateRules: Record<string, SlateRule>;

     

       100
       100
       +
         slateDecorators: Record<string, string>;

     

       101
       101
       +
         ruleBlacklists: Record<Ruleset, Record<string, boolean>>;

     

       102
       102
       +
       

     

       103
       103
       +
         addRule: (

     

       104
       104
       +
           name: string,

     

       105
       105
       +
           markdown: (rules: Record<string, MarkdownRule>) => MarkdownRule,

     

       106
       106
       +
           slate: (rules: Record<string, SlateRule>) => SlateRule,

     

       107
       107
       +
           decorator?: string | undefined

     

       108
       108
       +
         ) => void;

     

       109
       109
       +
         blacklistFromRuleset: (ruleset: Ruleset, name: string) => void;

     

       110
       110
       +
       };

packages/types/src/discord/require.ts

···

       6
       6
        
         CommonComponents,

     

       7
       7
        
         CommonFluxDispatcher

     

       8
       8
        
       } from "../coreExtensions";

     

       9
       9
       +
       import { Markdown } from "../coreExtensions/markdown";

     

       9
       10
        
       

     

       10
       11
        
       declare function WebpackRequire(id: string): any;

     

       11
       12
        
       declare function WebpackRequire(id: "spacepack_spacepack"): {

     
···

       24
       25
        
         Settings: Settings;

     

       25
       26
        
         default: Settings;

     

       26
       27
        
       };

     

       28
       28
       +
       

     

       29
       29
       +
       declare function WebpackRequire(id: "markdown_markdown"): Markdown;

     

       27
       30
        
       

     

       28
       31
        
       export default WebpackRequire;

packages/types/src/import.d.ts

···

       32
       32
        
         export const Settings: CoreExtensions.Settings;

     

       33
       33
        
         export default Settings;

     

       34
       34
        
       }

     

       35
       35
       +
       

     

       36
       36
       +
       declare module "@moonlight-mod/wp/markdown_markdown" {

     

       37
       37
       +
         import { CoreExtensions } from "@moonlight-mod/types";

     

       38
       38
       +
         const Markdown: CoreExtensions.Markdown.Markdown;

     

       39
       39
       +
         export = Markdown;

     

       40
       40
       +
       }