☰

Greasy Fork 支持简体中文。

Brazen Configuration Manager

Configuration management and related UI creation module

目前為 2023-09-03 提交的版本，檢視 最新版本。

此腳本不應該直接安裝，它是一個供其他腳本使用的函式庫。欲使用本函式庫，請在腳本 metadata 寫上： // @require https://update.cn-greasyfork.org/scripts/418665/1244654/Brazen%20Configuration%20Manager.js 

  1. // ==UserScript==
  2. // @name         Brazen Configuration Manager
  3. // @namespace    brazenvoid
  4. // @version      1.5.0
  5. // @author       brazenvoid
  6. // @license      GPL-3.0-only
  7. // @description  Configuration management and related UI creation module
  8. // ==/UserScript==
  9.  
  10. const CONFIG_TYPE_CHECKBOXES_GROUP = 'checkboxes'
  11. const CONFIG_TYPE_FLAG = 'flag'
  12. const CONFIG_TYPE_NUMBER = 'number'
  13. const CONFIG_TYPE_RADIOS_GROUP = 'radios'
  14. const CONFIG_TYPE_RANGE = 'range'
  15. const CONFIG_TYPE_RULESET = 'ruleset'
  16. const CONFIG_TYPE_SELECT = 'select'
  17. const CONFIG_TYPE_TEXT = 'text'
  18.  
  19. class BrazenConfigurationManager
  20. {
  21.     /**
  22.      * @typedef {{title: string, type: string, element: null|JQuery, value: *, maximum: int, minimum: int, options: string[], helpText: string,
  23.      *            onFormatForUI: ConfigurationManagerRulesetCallback, onTranslateFromUI: ConfigurationManagerRulesetCallback,
  24.      *            onOptimize: ConfigurationManagerRulesetCallback, createElement: Function, setFromUserInterface: Function, updateUserInterface: Function,
  25.      *            optimized?: *}} ConfigurationField
  26.      */
  27.  
  28.     /**
  29.      * @callback ConfigurationManagerRulesetCallback
  30.      * @param {*} values
  31.      */
  32.  
  33.     /**
  34.      * @callback ConfigurationManagerTagRulesetSelectorGeneratorCallback
  35.      * @param {string} tag
  36.      * @return {string}
  37.      */
  38.  
  39.     /**
  40.      * @callback ExternalConfigurationChangeCallback
  41.      * @param {BrazenConfigurationManager} manager
  42.      */
  43.  
  44.     /**
  45.      * @param {BrazenUIGenerator} uiGenerator
  46.      * @param {ConfigurationManagerTagRulesetSelectorGeneratorCallback|null} tagSelectorGenerator
  47.      * @return {BrazenConfigurationManager}
  48.      */
  49.     static create (uiGenerator, tagSelectorGenerator = null)
  50.     {
  51.         return new BrazenConfigurationManager(uiGenerator, tagSelectorGenerator)
  52.     }
  53.  
  54.     constructor (uiGenerator, tagSelectorGenerator = null)
  55.     {
  56.         /**
  57.          * @type {{}}
  58.          * @private
  59.          */
  60.         this._config = {}
  61.  
  62.         /**
  63.          * @type {ExternalConfigurationChangeCallback|null}
  64.          * @private
  65.          */
  66.         this._onExternalConfigurationChange = null
  67.  
  68.         /**
  69.          * @type {LocalStore}
  70.          * @private
  71.          */
  72.         this._localStore = null
  73.  
  74.         /**
  75.          * @type {LocalStore}
  76.          * @private
  77.          */
  78.         this._localStoreId = null;
  79.  
  80.         /**
  81.          * @type {number}
  82.          * @private
  83.          */
  84.         this._syncedLocalStoreId = 0
  85.         
  86.         /**
  87.          * @type {ConfigurationManagerTagRulesetSelectorGeneratorCallback|null}
  88.          * @private
  89.          */
  90.         this._tagSelectorGenerator = tagSelectorGenerator
  91.  
  92.         /**
  93.          * @type BrazenUIGenerator
  94.          * @private
  95.          */
  96.         this._uiGen = uiGenerator
  97.     }
  98.  
  99.     /**
  100.      * @param {string} type
  101.      * @param {string} name
  102.      * @param {*} value
  103.      * @param {string|null} helpText
  104.      * @return ConfigurationField
  105.      * @private
  106.      */
  107.     _createField (type, name, value, helpText)
  108.     {
  109.         let fieldKey = this._formatFieldKey(name)
  110.         let field = this._config[fieldKey]
  111.         if (!field) {
  112.             field = {
  113.                 element: null,
  114.                 helpText: helpText,
  115.                 title: name,
  116.                 type: type,
  117.                 value: value,
  118.                 createElement: null,
  119.                 setFromUserInterface: null,
  120.                 updateUserInterface: null,
  121.             }
  122.             this._config[fieldKey] = field
  123.         } else {
  124.             if (helpText) {
  125.                 field.helpText = helpText
  126.             }
  127.             field.value = value
  128.         }
  129.         return field
  130.     }
  131.  
  132.     /**
  133.      * @param {string} name
  134.      * @return {string}
  135.      * @private
  136.      */
  137.     _formatFieldKey (name)
  138.     {
  139.         return Utilities.toKebabCase(name)
  140.     }
  141.  
  142.     _regenerateStoreId ()
  143.     {
  144.         this._localStoreId.save({id: Utilities.generateId()})
  145.     }
  146.  
  147.     /**
  148.      * @param {boolean} ignoreIfDefaultsSet
  149.      * @private
  150.      */
  151.     _syncLocalStore (ignoreIfDefaultsSet)
  152.     {
  153.         let field
  154.         let storeObject = this._localStore.get()
  155.  
  156.         if (!ignoreIfDefaultsSet || !this._localStore.wereDefaultsSet()) {
  157.             for (let key in this._config) {
  158.  
  159.                 field = this._config[key]
  160.                 if (typeof storeObject[key] !== 'undefined') {
  161.  
  162.                     field.value = storeObject[key]
  163.                     if (field.type === CONFIG_TYPE_RULESET) {
  164.                         field.optimized = Utilities.callEventHandler(field.onOptimize, [field.value])
  165.                     }
  166.                 }
  167.             }
  168.             this.updateInterface()
  169.         }
  170.         return this
  171.     }
  172.  
  173.     /**
  174.      * @return {{}}
  175.      * @private
  176.      */
  177.     _toStoreObject ()
  178.     {
  179.         let storeObject = {}
  180.         for (let key in this._config) {
  181.             storeObject[key] = this._config[key].value
  182.         }
  183.         return storeObject
  184.     }
  185.  
  186.     addCheckboxesGroup (name, keyValuePairs, helpText)
  187.     {
  188.         let field = this._createField(CONFIG_TYPE_CHECKBOXES_GROUP, name, [], helpText)
  189.  
  190.         field.options = keyValuePairs
  191.  
  192.         field.createElement = () => {
  193.             field.element = this._uiGen.createFormCheckBoxesGroupSection(field.title, field.options, field.helpText)
  194.             return field.element
  195.         }
  196.         field.setFromUserInterface = () => {
  197.             field.value = []
  198.             field.element.find('input:checked').each((index, element) => {
  199.                 field.value.push($(element).attr('data-value'))
  200.             })
  201.         }
  202.         field.updateUserInterface = () => {
  203.             let elements = field.element.find('input')
  204.             for (let key of field.value) {
  205.                 elements.filter('[data-value="' + key + '"]').prop('checked', true)
  206.             }
  207.         }
  208.         return this
  209.     }
  210.  
  211.     addFlagField (name, helpText)
  212.     {
  213.         let field = this._createField(CONFIG_TYPE_FLAG, name, false, helpText)
  214.  
  215.         field.createElement = () => {
  216.             let inputGroup = this._uiGen.createFormInputGroup(field.title, 'checkbox', field.helpText)
  217.             field.element = inputGroup.find('input')
  218.             return inputGroup
  219.         }
  220.         field.setFromUserInterface = () => {
  221.             field.value = field.element.prop('checked')
  222.         }
  223.         field.updateUserInterface = () => {
  224.             field.element.prop('checked', field.value)
  225.         }
  226.         return this
  227.     }
  228.  
  229.     addNumberField (name, minimum, maximum, helpText)
  230.     {
  231.         let field = this._createField(CONFIG_TYPE_NUMBER, name, minimum, helpText)
  232.  
  233.         field.minimum = minimum
  234.         field.maximum = maximum
  235.  
  236.         field.createElement = () => {
  237.             let inputGroup = this._uiGen.createFormInputGroup(field.title, 'number', field.helpText).attr('min', field.minimum).attr('max', field.maximum)
  238.             field.element = inputGroup.find('input')
  239.             return inputGroup
  240.         }
  241.         field.setFromUserInterface = () => {
  242.             field.value = parseInt(field.element.val())
  243.         }
  244.         field.updateUserInterface = () => {
  245.             field.element.val(field.value)
  246.         }
  247.         return this
  248.     }
  249.  
  250.     addRadiosGroup (name, keyValuePairs, helpText)
  251.     {
  252.         let field = this._createField(CONFIG_TYPE_RADIOS_GROUP, name, keyValuePairs[0][1], helpText)
  253.  
  254.         field.options = keyValuePairs
  255.  
  256.         field.createElement = () => {
  257.             let inputGroup = this._uiGen.createFormRadiosGroupSection(field.title, field.options, field.helpText)
  258.             field.element = inputGroup
  259.             return inputGroup
  260.         }
  261.         field.setFromUserInterface = () => {
  262.             field.value = field.element.find('input:checked').attr('data-value')
  263.         }
  264.         field.updateUserInterface = () => {
  265.             field.element.find('input[data-value="' + field.value + '"]').prop('checked', true).trigger('change')
  266.         }
  267.         return this
  268.     }
  269.  
  270.     addRangeField (name, minimum, maximum, helpText)
  271.     {
  272.         let field = this._createField(CONFIG_TYPE_RANGE, name, {minimum: minimum, maximum: minimum}, helpText)
  273.  
  274.         field.minimum = minimum
  275.         field.maximum = maximum
  276.  
  277.         field.createElement = () => {
  278.             let inputGroup = this._uiGen.createFormRangeInputGroup(field.title, 'number', field.minimum, field.maximum, field.helpText)
  279.             field.element = inputGroup.find('input')
  280.             return inputGroup
  281.         }
  282.         field.setFromUserInterface = () => {
  283.             field.value = {
  284.                 minimum: field.element.first().val(),
  285.                 maximum: field.element.last().val(),
  286.             }
  287.         }
  288.         field.updateUserInterface = () => {
  289.             field.element.first().val(field.value.minimum)
  290.             field.element.last().val(field.value.maximum)
  291.         }
  292.         return this
  293.     }
  294.  
  295.     /**
  296.      * @param {string} name
  297.      * @param {number} rows
  298.      * @param {string|null} helpText
  299.      * @param {ConfigurationManagerRulesetCallback} onTranslateFromUI
  300.      * @param {ConfigurationManagerRulesetCallback} onFormatForUI
  301.      * @param {ConfigurationManagerRulesetCallback} onOptimize
  302.      * @return {BrazenConfigurationManager}
  303.      */
  304.     addRulesetField (name, rows, helpText, onTranslateFromUI = null, onFormatForUI = null, onOptimize = null)
  305.     {
  306.         let field = this._createField(CONFIG_TYPE_RULESET, name, [], helpText)
  307.  
  308.         field.optimized = null
  309.         field.onTranslateFromUI = onTranslateFromUI ?? field.onTranslateFromUI
  310.         field.onFormatForUI = onFormatForUI ?? field.onFormatForUI
  311.         field.onOptimize = onOptimize ?? field.onOptimize
  312.  
  313.         field.createElement = () => {
  314.             let inputGroup = this._uiGen.createFormTextAreaGroup(field.title, rows, field.helpText)
  315.             field.element = inputGroup.find('textarea')
  316.             return inputGroup
  317.         }
  318.         field.setFromUserInterface = () => {
  319.             let value = Utilities.trimAndKeepNonEmptyStrings(field.element.val().split(REGEX_LINE_BREAK))
  320.             field.value = Utilities.callEventHandler(field.onTranslateFromUI, [value], value)
  321.             field.optimized = Utilities.callEventHandler(field.onOptimize, [field.value])
  322.         }
  323.         field.updateUserInterface = () => {
  324.             field.element.val(Utilities.callEventHandler(field.onFormatForUI, [field.value], field.value).join('\n'))
  325.         }
  326.         return this
  327.     }
  328.  
  329.     addSelectField (name, keyValuePairs, helpText)
  330.     {
  331.         let field = this._createField(CONFIG_TYPE_SELECT, name, keyValuePairs[0][1], helpText)
  332.  
  333.         field.options = keyValuePairs
  334.  
  335.         field.createElement = () => {
  336.             let inputGroup = this._uiGen.createFormSelectGroup(field.title, field.options, field.helpText)
  337.             field.element = inputGroup.find('select')
  338.             return inputGroup
  339.         }
  340.         field.setFromUserInterface = () => {
  341.             field.value = field.element.val()
  342.         }
  343.         field.updateUserInterface = () => {
  344.             field.element.val(field.value).trigger('change')
  345.         }
  346.         return this
  347.     }
  348.     
  349.     /**
  350.      * @param {string} name
  351.      * @param {number} rows
  352.      * @param {string|null} helpText
  353.      * @return {BrazenConfigurationManager}
  354.      */
  355.     addTagRulesetField(name, rows = 10, helpText = null)
  356.     {
  357.         this.addRulesetField(name, rows, helpText, null, null, (rules) => {
  358.             
  359.             let orTags, iteratedRuleset
  360.             let optimizedRuleset = []
  361.             
  362.             // Operations
  363.             
  364.             let expandRuleset = (ruleset, tags) => {
  365.                 
  366.                 let grownRuleset = []
  367.                 for (let tag of tags) {
  368.                     for (let rule of ruleset) {
  369.                         grownRuleset.push([...rule, this._tagSelectorGenerator(tag)])
  370.                     }
  371.                 }
  372.                 return grownRuleset
  373.             }
  374.             
  375.             let growRuleset = (ruleset, tagToAdd) => {
  376.                 
  377.                 if (ruleset.length) {
  378.                     for (let rule of ruleset) {
  379.                         rule.push(this._tagSelectorGenerator(tagToAdd))
  380.                     }
  381.                 } else {
  382.                     let tags = typeof tagToAdd === 'string' ? [tagToAdd] : tagToAdd
  383.                     for (let tag of tags) {
  384.                         ruleset.push([this._tagSelectorGenerator(tag)])
  385.                     }
  386.                 }
  387.             }
  388.             
  389.             // Translate user defined rules
  390.             
  391.             for (let blacklistedRule of rules) {
  392.                 
  393.                 iteratedRuleset = []
  394.                 for (let andTag of blacklistedRule.split('&')) {
  395.                     
  396.                     orTags = andTag.split('|')
  397.                     if (orTags.length === 1) {
  398.                         growRuleset(iteratedRuleset, andTag)
  399.                     } else if (iteratedRuleset.length) {
  400.                         iteratedRuleset = expandRuleset(iteratedRuleset, orTags)
  401.                     } else {
  402.                         growRuleset(iteratedRuleset, orTags)
  403.                     }
  404.                 }
  405.                 optimizedRuleset = optimizedRuleset.concat(iteratedRuleset)
  406.             }
  407.             
  408.             // Sort rules by complexity
  409.             
  410.             return optimizedRuleset.sort((a, b) => a.length - b.length)
  411.         })
  412.     }
  413.     
  414.     addTextField (name, helpText)
  415.     {
  416.         let field = this._createField(CONFIG_TYPE_TEXT, name, '', helpText)
  417.  
  418.         field.createElement = () => {
  419.             let inputGroup = this._uiGen.createFormInputGroup(field.title, 'text', field.helpText)
  420.             field.element = inputGroup.find('input')
  421.             return inputGroup
  422.         }
  423.         field.setFromUserInterface = () => {
  424.             field.value = field.element.val()
  425.         }
  426.         field.updateUserInterface = () => {
  427.             field.element.val(field.value)
  428.         }
  429.         return this
  430.     }
  431.  
  432.     backup ()
  433.     {
  434.         let backupConfig = this._toStoreObject()
  435.         backupConfig.id = this._syncedLocalStoreId
  436.         return Utilities.objectToJSON(backupConfig)
  437.     }
  438.  
  439.     createElement (name)
  440.     {
  441.         return this.getFieldOrFail(name).createElement()
  442.     }
  443.     
  444.     /**
  445.      * @param {string} configKey
  446.      * @returns {function(*): boolean}
  447.      */
  448.     generateValidationCallback(configKey)
  449.     {
  450.         let validationCallback
  451.         switch (this.getField(configKey).type) {
  452.             case CONFIG_TYPE_FLAG:
  453.             case CONFIG_TYPE_RADIOS_GROUP:
  454.             case CONFIG_TYPE_SELECT:
  455.                 validationCallback = (value) => value
  456.                 break
  457.             case CONFIG_TYPE_CHECKBOXES_GROUP:
  458.                 validationCallback = (valueKeys) => valueKeys.length
  459.                 break
  460.             case CONFIG_TYPE_NUMBER:
  461.                 validationCallback = (value) => value > 0
  462.                 break
  463.             case CONFIG_TYPE_RANGE:
  464.                 validationCallback = (range) => range.minimum > 0 || range.maximum > 0
  465.                 break
  466.             case CONFIG_TYPE_RULESET:
  467.                 validationCallback = (rules) => rules.length
  468.                 break
  469.             case CONFIG_TYPE_TEXT:
  470.                 validationCallback = (value) => value.length
  471.                 break
  472.             default:
  473.                 throw new Error('Associated config type requires explicit validation callback definition.')
  474.         }
  475.         return validationCallback
  476.     }
  477.  
  478.     /**
  479.      * @param {string} name
  480.      * @return {ConfigurationField|null}
  481.      */
  482.     getField (name)
  483.     {
  484.         return this._config[this._formatFieldKey(name)]
  485.     }
  486.  
  487.     /**
  488.      * @param {string} name
  489.      * @return {ConfigurationField}
  490.      */
  491.     getFieldOrFail (name)
  492.     {
  493.         let field = this._config[this._formatFieldKey(name)]
  494.         if (field) {
  495.             return field
  496.         }
  497.         throw new Error('Field named "' + name + '" could not be found')
  498.     }
  499.  
  500.     getValue (name)
  501.     {
  502.         return this.getFieldOrFail(name).value
  503.     }
  504.  
  505.     /**
  506.      * @param {string} name
  507.      * @return {boolean}
  508.      */
  509.     hasField (name)
  510.     {
  511.         return typeof this.getField(name) !== 'undefined'
  512.     }
  513.  
  514.     /**
  515.      * @param scriptPrefix
  516.      * @return {BrazenConfigurationManager}
  517.      */
  518.     initialize (scriptPrefix)
  519.     {
  520.         this._localStore = new LocalStore(scriptPrefix + 'settings', this._toStoreObject())
  521.         this._localStore.onChange(() => this.updateInterface())
  522.  
  523.         this._localStoreId = new LocalStore(scriptPrefix + 'settings-id', {id: Utilities.generateId()})
  524.  
  525.         $(document).on('visibilitychange', () => {
  526.             if (!document.hidden && this._syncedLocalStoreId !== this._localStoreId.get().id) {
  527.                 this._syncLocalStore(true)
  528.                 Utilities.callEventHandler(this._onExternalConfigurationChange, [this])
  529.             }
  530.         })
  531.         return this._syncLocalStore(true)
  532.     }
  533.  
  534.     /**
  535.      * @param {ExternalConfigurationChangeCallback} eventHandler
  536.      * @return {BrazenConfigurationManager}
  537.      */
  538.     onExternalConfigurationChange (eventHandler)
  539.     {
  540.         this._onExternalConfigurationChange = eventHandler
  541.         return this
  542.     }
  543.  
  544.     /**
  545.      * @param {string} backedUpConfiguration
  546.      */
  547.     restore (backedUpConfiguration)
  548.     {
  549.         let backupConfig = Utilities.objectFromJSON(backedUpConfiguration)
  550.  
  551.         if (typeof backupConfig.id !== 'undefined') {
  552.             this._syncedLocalStoreId = backupConfig.id
  553.             this._localStoreId.save({id: backupConfig.id})
  554.             delete backupConfig.id
  555.         } else {
  556.             this._regenerateStoreId()
  557.         }
  558.  
  559.         this._localStore.save(backupConfig)
  560.         this._syncLocalStore(false)
  561.  
  562.         return this
  563.     }
  564.  
  565.     revertChanges ()
  566.     {
  567.         return this._syncLocalStore(false)
  568.     }
  569.  
  570.     save ()
  571.     {
  572.         this.update()._localStore.save(this._toStoreObject())
  573.         this._regenerateStoreId()
  574.  
  575.         return this
  576.     }
  577.  
  578.     update ()
  579.     {
  580.         let field
  581.         for (let fieldName in this._config) {
  582.             field = this._config[fieldName]
  583.             if (field.element) {
  584.                 field.setFromUserInterface()
  585.             }
  586.         }
  587.         return this
  588.     }
  589.  
  590.     updateInterface ()
  591.     {
  592.         let field
  593.         for (let fieldName in this._config) {
  594.             field = this._config[fieldName]
  595.             if (field.element) {
  596.                 field.updateUserInterface()
  597.             }
  598.         }
  599.         return this
  600.     }
  601. }