1633 lines
61 KiB
TypeScript
1633 lines
61 KiB
TypeScript
// Module ID: 11450
|
|
// Function ID: 89149
|
|
// Name: _createForOfIteratorHelperLoose
|
|
// Dependencies: []
|
|
|
|
// Module 11450 (_createForOfIteratorHelperLoose)
|
|
function _createForOfIteratorHelperLoose(@@iterator) {
|
|
let arg1 = Symbol_iterator;
|
|
@@iterator = "undefined" !== typeof Symbol;
|
|
if (Symbol_iterator) {
|
|
const _Symbol = Symbol;
|
|
@@iterator = Symbol_iterator[Symbol.iterator];
|
|
}
|
|
if (!Symbol_iterator) {
|
|
@@iterator = Symbol_iterator[Symbol.iterator];
|
|
}
|
|
if (Symbol_iterator) {
|
|
const iter = Symbol_iterator.call(Symbol_iterator);
|
|
const next = iter.next;
|
|
return next.bind(iter);
|
|
} else {
|
|
const _Array = Array;
|
|
let tmp = Symbol_iterator;
|
|
if (!Array.isArray(Symbol_iterator)) {
|
|
let tmp2;
|
|
if (Symbol_iterator) {
|
|
if ("string" === typeof Symbol_iterator) {
|
|
tmp2 = _arrayLikeToArray(Symbol_iterator, undefined);
|
|
} else {
|
|
const toString = {}.toString;
|
|
const substr = toString.call(Symbol_iterator).slice(8, -1);
|
|
let name = substr;
|
|
if (tmp3) {
|
|
name = Symbol_iterator.constructor.name;
|
|
}
|
|
if ("Map" !== name) {
|
|
if ("Set" !== name) {
|
|
if ("Arguments" === name) {
|
|
let arr = _arrayLikeToArray(Symbol_iterator, undefined);
|
|
} else {
|
|
const obj = /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/;
|
|
}
|
|
}
|
|
tmp2 = arr;
|
|
}
|
|
const _Array2 = Array;
|
|
arr = Array.from(Symbol_iterator);
|
|
const callResult = toString.call(Symbol_iterator);
|
|
const tmp3 = "Object" === substr && Symbol_iterator.constructor;
|
|
}
|
|
}
|
|
tmp = tmp2;
|
|
if (!tmp2) {
|
|
const _TypeError = TypeError;
|
|
const typeError = new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
|
|
throw typeError;
|
|
}
|
|
}
|
|
if (tmp) {
|
|
arg1 = tmp;
|
|
}
|
|
let closure_1 = 0;
|
|
return () => {
|
|
if (closure_1 >= tmp.length) {
|
|
let obj = { done: true };
|
|
} else {
|
|
obj = { done: false };
|
|
closure_1 = tmp3 + 1;
|
|
obj.value = tmp[+closure_1];
|
|
}
|
|
return obj;
|
|
};
|
|
}
|
|
}
|
|
function _arrayLikeToArray(arg0, arg1) {
|
|
let length;
|
|
if (tmp) {
|
|
length = arg0.length;
|
|
}
|
|
const ArrayResult = Array(length);
|
|
for (let num = 0; num < length; num = num + 1) {
|
|
ArrayResult[num] = arg0[num];
|
|
}
|
|
return ArrayResult;
|
|
}
|
|
function getNextOption(options) {
|
|
const importDefault = arg2;
|
|
options = options.options;
|
|
let found;
|
|
if (null != options) {
|
|
found = options.filter((required) => {
|
|
let tmp = required.required || arg2;
|
|
if (tmp) {
|
|
tmp = !arg1.has(required.name);
|
|
}
|
|
return tmp;
|
|
});
|
|
}
|
|
let first = null;
|
|
if (null != found) {
|
|
first = null;
|
|
if (found.length > 0) {
|
|
first = found[0];
|
|
}
|
|
}
|
|
return first;
|
|
}
|
|
let closure_4 = importDefault(dependencyMap[0]);
|
|
let closure_5 = importDefault(dependencyMap[1]);
|
|
let closure_6 = importDefault(dependencyMap[2]);
|
|
const DraftType = arg1(dependencyMap[3]).DraftType;
|
|
let closure_8 = importDefault(dependencyMap[4]);
|
|
({ AnalyticEvents: closure_9, AutoCompleteResultTypes: closure_10, WHITESPACE_RE: closure_11 } = arg1(dependencyMap[5]));
|
|
const COMMAND_SENTINEL = arg1(dependencyMap[6]).COMMAND_SENTINEL;
|
|
const MediaKeyboardTarget = arg1(dependencyMap[7]).MediaKeyboardTarget;
|
|
let closure_14 = { FULL_COMMAND: 0, [0]: "FULL_COMMAND", PARTIAL_COMMAND: 1, [1]: "PARTIAL_COMMAND" };
|
|
const tmp2 = arg1(dependencyMap[5]);
|
|
const tmp3 = () => {
|
|
class ApplicationCommandManager {
|
|
constructor(arg0) {
|
|
ApplicationCommandManager = this;
|
|
self = this;
|
|
tmp = closure_5(this, ApplicationCommandManager);
|
|
this.chatInputNodes = [];
|
|
map = new Map();
|
|
this.optionsToNodes = map;
|
|
map1 = new Map();
|
|
this.optionValueNodes = map1;
|
|
tmp4 = self(closure_3[8]);
|
|
tmp4 = new tmp4();
|
|
this.parser = tmp4;
|
|
this.optionValues = {};
|
|
this.optionValidationResults = {};
|
|
this.canAutoInsertFirstOption = true;
|
|
this.preferredOptionValues = {};
|
|
this.setAutoCompleteResult = (channelId, displayText) => {
|
|
let insertOrJumpCommandOption = arg3;
|
|
const activeOption = store.getActiveOption(channelId);
|
|
if (arg2) {
|
|
if (null != self.props.activeCommand) {
|
|
if (null != activeOption) {
|
|
const type = insertOrJumpCommandOption.type;
|
|
if (constants2.USER === type) {
|
|
let obj = { type: "userMention", userId: insertOrJumpCommandOption.user.id };
|
|
let tmp8 = obj;
|
|
insertOrJumpCommandOption = self.insertOrJumpCommandOption;
|
|
obj = { displayText, preferred: true, value: tmp8 };
|
|
const result = insertOrJumpCommandOption(activeOption, undefined, false, obj);
|
|
} else if (constants2.ROLE !== type) {
|
|
if (constants2.CHANNEL === type) {
|
|
const obj1 = { type: "channelMention", channelId: insertOrJumpCommandOption.channel.id };
|
|
tmp8 = obj1;
|
|
}
|
|
}
|
|
const obj2 = { type: "roleMention", roleId: insertOrJumpCommandOption.id };
|
|
tmp8 = obj2;
|
|
}
|
|
}
|
|
}
|
|
if (insertOrJumpCommandOption.type !== constants2.SLASH) {
|
|
return false;
|
|
} else {
|
|
obj = { channelId };
|
|
({ command: obj.command, section: obj.section, location: obj.location, visualSection: obj.visualSection, query: obj.query } = insertOrJumpCommandOption);
|
|
obj.addSpace = true;
|
|
self.setCommand(obj);
|
|
return true;
|
|
}
|
|
};
|
|
this.setCommand = (arg0) => {
|
|
let _location;
|
|
let channelId;
|
|
let command;
|
|
let commandText;
|
|
let query;
|
|
let section;
|
|
let visualSection;
|
|
({ command, query, commandText } = arg0);
|
|
const current = self.ref.current;
|
|
({ channelId, section, location: _location, visualSection } = arg0);
|
|
if (null == commandText) {
|
|
const _HermesInternal = HermesInternal;
|
|
let str = "";
|
|
const combined = "" + closure_12 + command.displayName;
|
|
if (tmp) {
|
|
str = " ";
|
|
}
|
|
commandText = combined + str;
|
|
}
|
|
current.setText(commandText);
|
|
let obj = self(closure_3[9]);
|
|
obj = { channelId, command, section, location: _location, triggerSection: self(closure_3[10]).getCommandTriggerSection(visualSection) };
|
|
let length;
|
|
if (null != query) {
|
|
length = query.length;
|
|
}
|
|
obj.queryLength = length;
|
|
obj.setActiveCommand(obj);
|
|
let id;
|
|
if (null != self) {
|
|
const preferredCommand = self.preferredCommand;
|
|
if (null != preferredCommand) {
|
|
id = preferredCommand.id;
|
|
}
|
|
}
|
|
if (command.id !== id) {
|
|
if (null != self) {
|
|
obj = {};
|
|
const obj1 = {};
|
|
const merged = Object.assign(command);
|
|
obj1["preferredCommandType"] = constants3.FULL_COMMAND;
|
|
obj.preferredCommand = obj1;
|
|
const result = self.updateApplicationCommandManagerState(obj);
|
|
}
|
|
}
|
|
};
|
|
this.setPartialCommand = (id, untranslatedName, location) => {
|
|
const current = self.ref.current;
|
|
current.setText("" + closure_12 + untranslatedName);
|
|
const preferredCommand = self.preferredCommand;
|
|
id = undefined;
|
|
if (null != preferredCommand) {
|
|
id = preferredCommand.id;
|
|
}
|
|
if (id !== id) {
|
|
let obj = {};
|
|
obj = { id, untranslatedName, displayName: untranslatedName, preferredCommandType: constants3.PARTIAL_COMMAND };
|
|
obj.preferredCommand = obj;
|
|
obj.location = location;
|
|
const result = self.updateApplicationCommandManagerState(obj);
|
|
}
|
|
};
|
|
this.setPastedCommand = (arg0, channel) => {
|
|
let application;
|
|
let bot;
|
|
let command;
|
|
let id;
|
|
let name;
|
|
const parsed = JSON.parse(arg0);
|
|
let obj = self(closure_3[10]);
|
|
const result = obj.extractInteractionDataProps(parsed);
|
|
let interactionOptions = result.interactionOptions;
|
|
let obj1 = callback(closure_3[11]);
|
|
obj = { type: "channel", channel };
|
|
const cachedCommand = obj1.getCachedCommand(obj, result.commandKey);
|
|
({ application, command } = cachedCommand);
|
|
let self = command;
|
|
if (null != command) {
|
|
let tmp8 = null;
|
|
if (null != application) {
|
|
obj = { type: self(closure_3[12]).ApplicationCommandSectionType.APPLICATION };
|
|
({ id: obj4.id, icon: obj4.icon, bot } = application);
|
|
let username;
|
|
if (null != bot) {
|
|
username = bot.username;
|
|
}
|
|
if (null == username) {
|
|
username = application.name;
|
|
}
|
|
obj.name = username;
|
|
obj.application = application;
|
|
tmp8 = obj;
|
|
}
|
|
if (null == interactionOptions) {
|
|
interactionOptions = [];
|
|
}
|
|
const initialValuesFromInteractionOptions = self(closure_3[13]).getInitialValuesFromInteractionOptions(command, interactionOptions);
|
|
self = initialValuesFromInteractionOptions;
|
|
const _Object = Object;
|
|
const keys = Object.keys(initialValuesFromInteractionOptions);
|
|
const mapped = keys.map((arg0) => {
|
|
const command = arg0;
|
|
const options = command.options;
|
|
let found;
|
|
if (null != options) {
|
|
found = options.find((name) => name.name === name);
|
|
}
|
|
const initialValuesFromInteractionOptions = iter;
|
|
if (null != found) {
|
|
if (null != iter) {
|
|
let str = iter.value;
|
|
str = undefined;
|
|
if (null != str) {
|
|
str = str.toString();
|
|
}
|
|
if (null != found.choices) {
|
|
const choices = found.choices;
|
|
const found1 = choices.find((value) => value.value === iter.value);
|
|
let displayName;
|
|
if (null != found1) {
|
|
displayName = found1.displayName;
|
|
}
|
|
str = displayName;
|
|
}
|
|
const _HermesInternal = HermesInternal;
|
|
return "" + found.displayName + ":" + str;
|
|
}
|
|
}
|
|
return null;
|
|
});
|
|
const found = mapped.filter((arg0) => null != arg0);
|
|
const joined = found.join(" ");
|
|
obj1 = { channelId: channel.id, command, section: tmp8, location: self(closure_3[12]).ApplicationCommandTriggerLocations.PASTE };
|
|
const _HermesInternal = HermesInternal;
|
|
let str2 = "";
|
|
const combined = "" + closure_12 + command.displayName;
|
|
if (0 !== joined.length) {
|
|
const _HermesInternal2 = HermesInternal;
|
|
str2 = " " + joined;
|
|
}
|
|
obj1.commandText = combined + str2;
|
|
self.setCommand(obj1);
|
|
const obj5 = self(closure_3[13]);
|
|
} else {
|
|
({ id, name } = parsed);
|
|
self.setPartialCommand(id, name, self(closure_3[12]).ApplicationCommandTriggerLocations.PASTE);
|
|
}
|
|
};
|
|
this.updateApplicationCommandManagerState = (newState) => {
|
|
let _location;
|
|
let preferredCommand;
|
|
let props = newState.newState;
|
|
const obj = {};
|
|
({ preferredCommand, location: _location } = newState);
|
|
if (null == props) {
|
|
props = self.props;
|
|
}
|
|
const merged = Object.assign(props);
|
|
obj["preferredCommand"] = preferredCommand;
|
|
obj["location"] = _location;
|
|
self.mergePropsAndUpdate(obj);
|
|
};
|
|
this.addCommandOptionParserRules = () => {
|
|
const parser = self.parser;
|
|
let obj = {
|
|
type: self(closure_3[8]).ChatInputNodeType.COMMAND_OPTION,
|
|
matchFunction(arg0, arg1) {
|
|
return lib(closure_3[14]).getMatchedOptions(arg0, arg1);
|
|
},
|
|
style() {
|
|
const styles = lib.styles;
|
|
return styles.commandOption();
|
|
}
|
|
};
|
|
parser.addRule(obj);
|
|
const parser2 = self.parser;
|
|
obj = {
|
|
ruleId: "commandOptionValueParserRuleId",
|
|
type: self(closure_3[8]).ChatInputNodeType.COMMAND_OPTION_WITH_VALUE,
|
|
matchFunction(arg0, arg1) {
|
|
return lib(closure_3[14]).getMatchedOptionsWithValue(arg0, arg1);
|
|
},
|
|
style() {
|
|
const styles = lib.styles;
|
|
return styles.commandOption();
|
|
},
|
|
editDisabled(data) {
|
|
data = data.data;
|
|
let type;
|
|
if (null != data) {
|
|
type = data.option.type;
|
|
}
|
|
return type === lib(closure_3[15]).ApplicationCommandOptionType.ATTACHMENT;
|
|
}
|
|
};
|
|
parser2.addRule(obj);
|
|
const parser3 = self.parser;
|
|
obj = {
|
|
ruleId: "emojiHighlightRuleId",
|
|
type: self(closure_3[8]).ChatInputNodeType.EMOJI_HIGHLIGHT,
|
|
matchFunction(arg0) {
|
|
return lib(closure_3[14]).getEmojiHighlightNodes(lib.props.channel, arg0);
|
|
},
|
|
style() {
|
|
const styles = lib.styles;
|
|
return styles.autocomplete();
|
|
},
|
|
editDisabled() {
|
|
return false;
|
|
}
|
|
};
|
|
parser3.addRule(obj);
|
|
const parser4 = self.parser;
|
|
parser4.addRule({
|
|
ruleId: "roleHighlightRuleId",
|
|
type: self(closure_3[8]).ChatInputNodeType.ROLE_HIGHLIGHT,
|
|
matchFunction(arg0) {
|
|
return lib(closure_3[14]).getRoleHighlightNodes(lib.props.channel, arg0);
|
|
},
|
|
style(data) {
|
|
data = data.data;
|
|
let color;
|
|
if (null != data) {
|
|
color = data.color;
|
|
}
|
|
const styles = lib.styles;
|
|
let tmp2;
|
|
if (null != color) {
|
|
tmp2 = color;
|
|
}
|
|
return styles.autocomplete(tmp2);
|
|
},
|
|
editDisabled() {
|
|
return false;
|
|
}
|
|
});
|
|
const parser5 = self.parser;
|
|
const obj1 = {
|
|
ruleId: "roleHighlightRuleId",
|
|
type: self(closure_3[8]).ChatInputNodeType.ROLE_HIGHLIGHT,
|
|
matchFunction(arg0) {
|
|
return lib(closure_3[14]).getRoleHighlightNodes(lib.props.channel, arg0);
|
|
},
|
|
style(data) {
|
|
data = data.data;
|
|
let color;
|
|
if (null != data) {
|
|
color = data.color;
|
|
}
|
|
const styles = lib.styles;
|
|
let tmp2;
|
|
if (null != color) {
|
|
tmp2 = color;
|
|
}
|
|
return styles.autocomplete(tmp2);
|
|
},
|
|
editDisabled() {
|
|
return false;
|
|
}
|
|
};
|
|
parser5.addRule({
|
|
ruleId: "userHighlightRuleId",
|
|
type: self(closure_3[8]).ChatInputNodeType.USER_HIGHLIGHT,
|
|
matchFunction(arg0) {
|
|
return lib(closure_3[14]).getUsernameHighlightNodes(lib.props.channel, arg0);
|
|
},
|
|
style() {
|
|
const styles = lib.styles;
|
|
return styles.autocomplete();
|
|
},
|
|
editDisabled() {
|
|
return false;
|
|
}
|
|
});
|
|
const parser6 = self.parser;
|
|
const obj2 = {
|
|
ruleId: "userHighlightRuleId",
|
|
type: self(closure_3[8]).ChatInputNodeType.USER_HIGHLIGHT,
|
|
matchFunction(arg0) {
|
|
return lib(closure_3[14]).getUsernameHighlightNodes(lib.props.channel, arg0);
|
|
},
|
|
style() {
|
|
const styles = lib.styles;
|
|
return styles.autocomplete();
|
|
},
|
|
editDisabled() {
|
|
return false;
|
|
}
|
|
};
|
|
parser6.addRule({
|
|
ruleId: "channelHighlightRuleId",
|
|
type: self(closure_3[8]).ChatInputNodeType.CHANNEL_HIGHLIGHT,
|
|
matchFunction(arg0) {
|
|
return lib(closure_3[14]).getChannelHighlightNodes(lib.props.channel, arg0);
|
|
},
|
|
style() {
|
|
const styles = lib.styles;
|
|
return styles.autocomplete();
|
|
},
|
|
editDisabled() {
|
|
return false;
|
|
}
|
|
});
|
|
const parser7 = self.parser;
|
|
const obj3 = {
|
|
ruleId: "channelHighlightRuleId",
|
|
type: self(closure_3[8]).ChatInputNodeType.CHANNEL_HIGHLIGHT,
|
|
matchFunction(arg0) {
|
|
return lib(closure_3[14]).getChannelHighlightNodes(lib.props.channel, arg0);
|
|
},
|
|
style() {
|
|
const styles = lib.styles;
|
|
return styles.autocomplete();
|
|
},
|
|
editDisabled() {
|
|
return false;
|
|
}
|
|
};
|
|
parser7.addRule({
|
|
ruleId: "silentHighlightRuleId",
|
|
type: self(closure_3[8]).ChatInputNodeType.SILENT_HIGHLIGHT,
|
|
matchFunction(arg0) {
|
|
return lib(closure_3[14]).getSilentHighlightNodes(arg0);
|
|
},
|
|
style() {
|
|
const styles = lib.styles;
|
|
return styles.autocomplete();
|
|
},
|
|
editDisabled() {
|
|
return false;
|
|
}
|
|
});
|
|
};
|
|
this.getCurrentCommand = (str, channel, displayName, section) => {
|
|
let text;
|
|
let self = channel;
|
|
self = displayName;
|
|
if (null != str) {
|
|
if (!self.props.commandsDisabled) {
|
|
if (str.startsWith(closure_12)) {
|
|
let obj = self(commandContext[14]);
|
|
const textBeforeFirstOption = obj.getTextBeforeFirstOption(str);
|
|
({ match: closure_2, text } = textBeforeFirstOption);
|
|
let flag = false;
|
|
if (null != displayName) {
|
|
const _HermesInternal = HermesInternal;
|
|
if (text.startsWith("" + closure_12 + displayName.displayName)) {
|
|
flag = true;
|
|
if (displayName.preferredCommandType === constants3.FULL_COMMAND) {
|
|
obj = { command: displayName, section };
|
|
return obj;
|
|
}
|
|
} else {
|
|
const _HermesInternal2 = HermesInternal;
|
|
flag = false;
|
|
}
|
|
}
|
|
if (null == self.contextCommands) {
|
|
return null;
|
|
} else {
|
|
obj = { channel, type: "channel" };
|
|
const commandContext = self(commandContext[16]).getCommandContext(obj);
|
|
let preferredCommandType;
|
|
if (null != displayName) {
|
|
preferredCommandType = displayName.preferredCommandType;
|
|
}
|
|
if (preferredCommandType === constants3.PARTIAL_COMMAND) {
|
|
const contextCommands = self.contextCommands;
|
|
const found = contextCommands.find((id) => id.id === arg2.id);
|
|
if (null != found) {
|
|
let obj2 = callback(commandContext[11]);
|
|
const obj1 = { channel, type: "channel" };
|
|
const cachedApplicationSection = obj2.getCachedApplicationSection(obj1, self(commandContext[15]).ApplicationCommandType.CHAT, found.applicationId);
|
|
let tmp21 = null;
|
|
if (null != cachedApplicationSection) {
|
|
obj2 = {};
|
|
const obj3 = {};
|
|
const merged = Object.assign(found);
|
|
obj3["preferredCommandType"] = constants3.FULL_COMMAND;
|
|
obj2.command = obj3;
|
|
obj2.section = cachedApplicationSection;
|
|
tmp21 = obj2;
|
|
}
|
|
return tmp21;
|
|
}
|
|
} else {
|
|
const parts = text.slice(1).split(" ", 3);
|
|
function _loop() {
|
|
const substr = parts.slice(0, parts.length - num5);
|
|
const joined = substr.join(" ");
|
|
const arg1 = joined;
|
|
let obj1 = arg1(closure_3[10]);
|
|
let obj2 = arg2(closure_3[17]);
|
|
const regExp = new RegExp("^" + obj2.escape(joined), "i");
|
|
const matchingGroupCommands = obj1.getMatchingGroupCommands(arg2.contextCommands, regExp, closure_3, 2);
|
|
const found = matchingGroupCommands.filter((inputType) => {
|
|
let tmp = inputType.inputType !== joined(closure_3[12]).ApplicationCommandInputType.PLACEHOLDER;
|
|
if (tmp) {
|
|
let tmp3 = inputType.displayName === joined;
|
|
if (!tmp3) {
|
|
tmp3 = inputType.untranslatedName === joined;
|
|
}
|
|
tmp = tmp3;
|
|
}
|
|
return tmp;
|
|
});
|
|
if (found.length > 0) {
|
|
const first = found[0];
|
|
let tmp5 = num5 > 0;
|
|
if (!tmp5) {
|
|
tmp5 = null != callback;
|
|
}
|
|
let obj3 = callback(closure_3[11]);
|
|
let obj = { channel: arg1, type: "channel" };
|
|
const cachedApplicationSection = obj3.getCachedApplicationSection(obj, arg1(closure_3[15]).ApplicationCommandType.CHAT, first.applicationId);
|
|
if (null == cachedApplicationSection) {
|
|
obj = { v: null };
|
|
obj1 = obj;
|
|
} else {
|
|
obj1 = {};
|
|
obj2 = {};
|
|
obj3 = {};
|
|
const merged = Object.assign(first);
|
|
obj3["preferredCommandType"] = constants.FULL_COMMAND;
|
|
obj2.command = obj3;
|
|
obj2.section = cachedApplicationSection;
|
|
obj1.v = obj2;
|
|
}
|
|
return obj1;
|
|
}
|
|
return matchingGroupCommands.length > 0 ? 0 : undefined;
|
|
}
|
|
let num5 = 0;
|
|
if (0 < parts.length) {
|
|
let _loopResult = _loop();
|
|
num5 = 0;
|
|
if (0 !== _loopResult) {
|
|
while (!_loopResult) {
|
|
num5 = num5 + 1;
|
|
if (num5 < parts.length) {
|
|
_loopResult = _loop();
|
|
}
|
|
}
|
|
return _loopResult.v;
|
|
}
|
|
}
|
|
const str2 = text.slice(1);
|
|
}
|
|
let tmp16 = null;
|
|
if (flag) {
|
|
tmp16 = null;
|
|
if (null != displayName) {
|
|
const obj4 = { command: displayName, section: null };
|
|
tmp16 = obj4;
|
|
}
|
|
}
|
|
return tmp16;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return null;
|
|
};
|
|
this.getCurrentOption = (arg0, arg1) => {
|
|
const self = arg1;
|
|
if (arg0) {
|
|
const _Array = Array;
|
|
const optionValueNodes = self.optionValueNodes;
|
|
const findLastResult = self(closure_3[18]).findLast(Array.from(optionValueNodes.values()), (location) => location.location <= arg1);
|
|
if (null != findLastResult) {
|
|
const data = findLastResult.data;
|
|
if (null != data) {
|
|
const option = data.option;
|
|
}
|
|
}
|
|
if (null != findLastResult) {
|
|
if (null != option) {
|
|
let tmp9;
|
|
if (null != self.preferredOptionValues[closure_0.props.channel.id]) {
|
|
tmp9 = tmp8[option.name];
|
|
}
|
|
return option;
|
|
}
|
|
}
|
|
return null;
|
|
} else {
|
|
return null;
|
|
}
|
|
};
|
|
this.getAllCommandOptionValues = (options, str) => {
|
|
let arr;
|
|
let iter;
|
|
let tmp3;
|
|
if (null == options.options) {
|
|
return {};
|
|
} else {
|
|
const obj = {};
|
|
const tmp17 = callback2(self.optionValueNodes);
|
|
const iter3 = tmp17();
|
|
let iter2 = iter3;
|
|
if (!iter3.done) {
|
|
do {
|
|
let tmp = closure_4;
|
|
let tmp2 = closure_4(iter2.value, 2);
|
|
[tmp3, arr] = tmp2;
|
|
let data = arr.data;
|
|
let type;
|
|
if (null != data) {
|
|
type = data.type;
|
|
}
|
|
let tmp5 = closure_0;
|
|
let tmp6 = closure_3;
|
|
if (type === closure_0(closure_3[8]).ChatInputParseResultDataType.COMMAND_OPTION) {
|
|
let tmp18 = closure_0;
|
|
let tmp19 = closure_0.preferredOptionValues[closure_0.props.channel.id];
|
|
let tmp8 = tmp19;
|
|
let optionValue;
|
|
if (null != tmp19) {
|
|
let tmp7 = tmp19[tmp3];
|
|
tmp8 = tmp7;
|
|
if (null != tmp7) {
|
|
optionValue = tmp7.optionValue;
|
|
tmp8 = tmp7;
|
|
}
|
|
}
|
|
if (null != optionValue) {
|
|
let items = [optionValue];
|
|
obj[tmp3] = items;
|
|
let tmp13 = tmp8;
|
|
let tmp14 = optionValue;
|
|
} else {
|
|
let option = arr.data.option;
|
|
let tmp10 = closure_0;
|
|
let optionValueParser = closure_0.optionValueParser;
|
|
let items1 = [optionValueParser.parse(str.substring(arr.location + option.displayName.length + 1, arr.location + arr.length), option)];
|
|
obj[tmp3] = items1;
|
|
let tmp11 = tmp8;
|
|
let tmp12 = optionValue;
|
|
}
|
|
}
|
|
iter = tmp17();
|
|
iter2 = iter;
|
|
} while (!iter.done);
|
|
}
|
|
return obj;
|
|
}
|
|
};
|
|
this.insertFirstOptionIfValid = (str, displayName) => {
|
|
if (str.startsWith("" + closure_12 + arg2)) {
|
|
if (str.length > arg2.length + 1) {
|
|
if (regex.test(str[arg2.length + 1])) {
|
|
const _Set = Set;
|
|
const optionValueNodes = self.optionValueNodes;
|
|
const set = new Set(optionValueNodes.keys());
|
|
const tmp10 = callback3(displayName, set, true);
|
|
if (null != tmp10) {
|
|
const result = self.insertOrJumpCommandOption(tmp10, displayName.displayName.length + 2, true, undefined, displayName);
|
|
}
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
};
|
|
this.insertOrJumpCommandOption = (name, arg1, arg2, displayText) => {
|
|
let selectionStart;
|
|
let text;
|
|
let flag = arg2;
|
|
let activeCommand = arg4;
|
|
if (arg2 === undefined) {
|
|
flag = false;
|
|
}
|
|
if (null == activeCommand) {
|
|
activeCommand = self.props.activeCommand;
|
|
}
|
|
if (null != activeCommand) {
|
|
({ text, selectionStart } = self.props);
|
|
const optionValueNodes2 = self.optionValueNodes;
|
|
if (null != optionValueNodes2) {
|
|
const value = optionValueNodes2.get(name.name);
|
|
}
|
|
displayText = undefined;
|
|
if (null != displayText) {
|
|
displayText = displayText.displayText;
|
|
}
|
|
if (null == displayText) {
|
|
if (null == value) {
|
|
if (null != arg1) {
|
|
selectionStart = arg1;
|
|
}
|
|
let tmp30 = null != text && selectionStart <= text.length;
|
|
if (tmp30) {
|
|
const _Math3 = Math;
|
|
tmp30 = !regex.test(text[Math.min(Math, selectionStart - 1, text.length - 1)]);
|
|
}
|
|
const current3 = self.ref.current;
|
|
let obj = { location: selectionStart, length: 0 };
|
|
let str8 = "";
|
|
if (tmp30) {
|
|
str8 = " ";
|
|
}
|
|
const _HermesInternal6 = HermesInternal;
|
|
obj.text = "" + str8 + name.displayName + ":";
|
|
obj = { type: self(closure_3[8]).ChatInputNodeType.COMMAND_OPTION };
|
|
const styles3 = self.styles;
|
|
obj.style = styles3.commandOption();
|
|
let num11 = 0;
|
|
if (tmp30) {
|
|
num11 = 1;
|
|
}
|
|
obj.location = num11;
|
|
obj.length = name.displayName.length + 1;
|
|
const items = [obj];
|
|
obj.nodes = items;
|
|
obj.keepCursorPosition = flag;
|
|
obj.editId = self.editId;
|
|
current3.replaceRange(obj);
|
|
} else {
|
|
const current2 = self.ref.current;
|
|
current2.setSelectedRange(value.location + name.displayName.length + 1, value.length - name.displayName.length - 1);
|
|
}
|
|
} else {
|
|
if (null != value) {
|
|
let _location = value.location;
|
|
} else {
|
|
_location = selectionStart;
|
|
if (null != arg1) {
|
|
_location = arg1;
|
|
}
|
|
}
|
|
let num = 0;
|
|
if (null != value) {
|
|
num = value.length;
|
|
}
|
|
let tmp3 = null != text && _location <= text.length;
|
|
if (tmp3) {
|
|
const _Math = Math;
|
|
tmp3 = !regex.test(text[Math.min(Math, _location - 1, text.length - 1)]);
|
|
}
|
|
const _Set = Set;
|
|
const optionValueNodes = self.optionValueNodes;
|
|
const set = new Set(optionValueNodes.keys());
|
|
set.add(name.name);
|
|
const tmp13 = callback3(activeCommand, set);
|
|
let tmp14 = null != displayText;
|
|
if (tmp14) {
|
|
let tmp15 = _location + num !== text.length;
|
|
if (tmp15) {
|
|
const _Math2 = Math;
|
|
tmp15 = !regex.test(text[Math.min(Math, _location + num, text.length - 1)]);
|
|
}
|
|
if (!tmp15) {
|
|
tmp15 = null != tmp13;
|
|
}
|
|
tmp14 = tmp15;
|
|
}
|
|
let displayText1;
|
|
if (null != displayText) {
|
|
displayText1 = displayText.displayText;
|
|
}
|
|
if ("" !== displayText1) {
|
|
const _HermesInternal2 = HermesInternal;
|
|
let combined = "" + name.displayName + ":" + displayText.displayText;
|
|
} else {
|
|
const _HermesInternal = HermesInternal;
|
|
combined = "" + name.displayName + ":";
|
|
}
|
|
let str4 = "";
|
|
if (tmp3) {
|
|
str4 = " ";
|
|
}
|
|
let str5 = "";
|
|
if (tmp14) {
|
|
str5 = " ";
|
|
}
|
|
const _HermesInternal3 = HermesInternal;
|
|
const combined1 = "" + str4 + combined + str5;
|
|
if (null != tmp13) {
|
|
const _HermesInternal4 = HermesInternal;
|
|
const combined2 = "" + tmp13.displayName + ":";
|
|
const _HermesInternal5 = HermesInternal;
|
|
const obj1 = {};
|
|
const combined3 = "" + combined1 + combined2;
|
|
obj1.type = self(closure_3[8]).ChatInputNodeType.COMMAND_OPTION_WITH_VALUE;
|
|
const styles = self.styles;
|
|
obj1.style = styles.commandOption();
|
|
let num6 = 0;
|
|
if (tmp3) {
|
|
num6 = 1;
|
|
}
|
|
obj1.location = num6;
|
|
obj1.length = combined.length;
|
|
const items1 = [obj1, ];
|
|
const obj2 = { type: self(closure_3[8]).ChatInputNodeType.COMMAND_OPTION };
|
|
const styles2 = self.styles;
|
|
obj2.style = styles2.commandOption();
|
|
obj2.location = combined1.length;
|
|
obj2.length = combined2.length;
|
|
items1[1] = obj2;
|
|
const current = self.ref.current;
|
|
const obj3 = { location: _location, length: num, text: combined3, nodes: items1, editId: self.editId };
|
|
current.replaceRange(obj3);
|
|
} else {
|
|
const current4 = self.ref.current;
|
|
const obj4 = { location: _location, length: num, text: combined1 };
|
|
const obj5 = { type: self(closure_3[8]).ChatInputNodeType.COMMAND_OPTION_WITH_VALUE };
|
|
const styles4 = self.styles;
|
|
obj5.style = styles4.commandOption();
|
|
let num4 = 0;
|
|
if (tmp3) {
|
|
num4 = 1;
|
|
}
|
|
obj5.location = num4;
|
|
obj5.length = combined.length;
|
|
const items2 = [obj5];
|
|
obj4.nodes = items2;
|
|
obj4.keepCursorPosition = flag;
|
|
obj4.editId = self.editId;
|
|
current4.replaceRange(obj4);
|
|
}
|
|
}
|
|
if (tmp40) {
|
|
if (null != self) {
|
|
const result = self.setPreferredOptionValue(self.props.channel.id, name.name, displayText);
|
|
}
|
|
}
|
|
const tmp40 = null != displayText && displayText.preferred;
|
|
}
|
|
};
|
|
this.sendCommand = (substr1, id) => {
|
|
let commands;
|
|
let sections;
|
|
const activeCommand = self.props.activeCommand;
|
|
if (null != activeCommand) {
|
|
let obj2 = self(closure_3[19]);
|
|
let prop = self.optionValidationResults;
|
|
if (null == prop) {
|
|
prop = {};
|
|
}
|
|
const firstInvalidOption = obj2.getFirstInvalidOption(activeCommand, prop);
|
|
let obj = {};
|
|
let self = obj;
|
|
const _Object = Object;
|
|
const entries = Object.entries(store.getOptionStates(id.id));
|
|
const item = entries.forEach((arg0) => {
|
|
let tmp;
|
|
let tmp2;
|
|
[tmp, tmp2] = arg0;
|
|
if (null != tmp2.optionValue) {
|
|
obj[tmp] = tmp2.optionValue;
|
|
}
|
|
});
|
|
if (null == firstInvalidOption) {
|
|
arg2(activeCommand, self(closure_3[20]).parseOptionValuesForSend(id, activeCommand, obj));
|
|
const obj6 = self(closure_3[20]);
|
|
} else {
|
|
const result = self.insertOrJumpCommandOption(firstInvalidOption);
|
|
const result1 = self.updateValidationResults();
|
|
const result2 = self(closure_3[21]).triggerHapticFeedback(self(closure_3[21]).HapticFeedbackTypes.NOTIFICATION_ERROR);
|
|
const obj10 = self(closure_3[21]);
|
|
obj = {};
|
|
let applicationId;
|
|
if (null != activeCommand) {
|
|
applicationId = activeCommand.applicationId;
|
|
}
|
|
obj.application_id = applicationId;
|
|
id = undefined;
|
|
if (null != activeCommand) {
|
|
const rootCommand = activeCommand.rootCommand;
|
|
if (null != rootCommand) {
|
|
id = rootCommand.id;
|
|
}
|
|
}
|
|
obj.command_id = id;
|
|
const type = firstInvalidOption.type;
|
|
let num5 = 3;
|
|
if (null != type) {
|
|
num5 = type;
|
|
}
|
|
obj.argument_type = self(closure_3[15]).ApplicationCommandOptionType[num5];
|
|
let required;
|
|
if (null != firstInvalidOption) {
|
|
required = firstInvalidOption.required;
|
|
}
|
|
obj.is_required = required;
|
|
self(closure_3[22]).trackWithMetadata(constants.APPLICATION_COMMAND_VALIDATION_FAILED, obj);
|
|
const obj11 = self(closure_3[22]);
|
|
}
|
|
return true;
|
|
} else {
|
|
let query = null;
|
|
if (obj7.getPrefix(substr1) === closure_12) {
|
|
obj = self(closure_3[23]);
|
|
query = obj.getQuery(substr1);
|
|
}
|
|
if (null != query) {
|
|
const obj1 = { channel: id, type: "channel" };
|
|
const obj8 = callback(closure_3[11]);
|
|
({ commands, sections } = callback(closure_3[11]).getCachedResults(obj1, self(closure_3[15]).ApplicationCommandType.CHAT, query));
|
|
if (null != commands) {
|
|
if (commands.length > 0) {
|
|
if (commands[0].inputType !== self(closure_3[12]).ApplicationCommandInputType.PLACEHOLDER) {
|
|
const first = commands[0];
|
|
self = first;
|
|
const found = sections.find((application) => {
|
|
application = application.application;
|
|
let id;
|
|
if (null != application) {
|
|
id = application.id;
|
|
}
|
|
return id === first.applicationId;
|
|
});
|
|
obj2 = { channelId: id.id, command: first };
|
|
let tmp9 = null;
|
|
if (null != found) {
|
|
tmp9 = found;
|
|
}
|
|
obj2.section = tmp9;
|
|
obj2.location = self(closure_3[12]).ApplicationCommandTriggerLocations.DISCOVERY;
|
|
obj2.query = query;
|
|
self.setCommand(obj2);
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
const cachedResults = callback(closure_3[11]).getCachedResults(obj1, self(closure_3[15]).ApplicationCommandType.CHAT, query);
|
|
}
|
|
return false;
|
|
}
|
|
};
|
|
({ props: this.props, ref: this.ref, optionValueParser: this.optionValueParser, styles: this.styles } = arg0);
|
|
result = this.addCommandOptionParserRules();
|
|
return;
|
|
}
|
|
}
|
|
const arg1 = ApplicationCommandManager;
|
|
let obj = {
|
|
key: "setPreferredOptionValue",
|
|
value: function setPreferredOptionValue(id, name, displayText) {
|
|
const self = this;
|
|
if (null == this.preferredOptionValues[id]) {
|
|
self.preferredOptionValues[id] = {};
|
|
}
|
|
self.preferredOptionValues[id][name] = displayText;
|
|
}
|
|
};
|
|
const items = [obj, , ];
|
|
obj = {
|
|
key: "mergePropsAndUpdate",
|
|
value: function mergePropsAndUpdate(editId) {
|
|
let activeCommand;
|
|
let channel;
|
|
let command;
|
|
let focused;
|
|
let iter2;
|
|
let lastCommandAutocompleteResponseNonce;
|
|
let queryCommands;
|
|
let section;
|
|
let selectionEnd;
|
|
let selectionStart;
|
|
let text;
|
|
const self = this;
|
|
const ApplicationCommandManager = this;
|
|
const props = this.props;
|
|
({ text, editId, channel } = props);
|
|
let preferredCommandType4 = editId !== editId.editId;
|
|
({ selectionStart, selectionEnd, focused, queryCommands, lastCommandAutocompleteResponseNonce } = props);
|
|
if (preferredCommandType4) {
|
|
preferredCommandType4 = null != editId.editId;
|
|
}
|
|
if (preferredCommandType4) {
|
|
self.editId = editId.editId;
|
|
}
|
|
const tmp3 = text !== editId.text;
|
|
({ activeCommand, activeCommandSection: section } = self);
|
|
if (!tmp3) {
|
|
if (queryCommands === editId.queryCommands) {
|
|
let tmp7 = section;
|
|
let flag = false;
|
|
}
|
|
let id;
|
|
if (null != activeCommand) {
|
|
id = activeCommand.id;
|
|
}
|
|
const activeCommand3 = self.activeCommand;
|
|
let id1;
|
|
if (null != activeCommand3) {
|
|
id1 = activeCommand3.id;
|
|
}
|
|
let tmp45 = id !== id1;
|
|
let activeOption = self.activeOption;
|
|
let currentOption = activeOption;
|
|
let tmp46 = tmp3;
|
|
if (!tmp3) {
|
|
tmp46 = tmp4;
|
|
}
|
|
if (!tmp46) {
|
|
tmp46 = tmp5;
|
|
}
|
|
if (!tmp46) {
|
|
tmp46 = tmp45;
|
|
}
|
|
if (tmp46) {
|
|
let focused2 = editId.focused;
|
|
if (!focused2) {
|
|
let obj4 = ApplicationCommandManager(tmp45[25]);
|
|
const keyboardType = obj4.getKeyboardType();
|
|
focused2 = keyboardType !== ApplicationCommandManager(tmp45[26]).KeyboardTypes.SYSTEM;
|
|
}
|
|
currentOption = self.getCurrentOption(focused2, editId.selectionStart);
|
|
activeOption = currentOption;
|
|
}
|
|
let tmp51 = tmp45;
|
|
if (tmp45) {
|
|
tmp51 = null != self.activeCommand;
|
|
}
|
|
if (tmp51) {
|
|
let obj5 = editId(tmp45[24]);
|
|
obj5.clearAll(channel.id, closure_7.SlashCommand);
|
|
}
|
|
let name;
|
|
if (null != activeOption) {
|
|
name = activeOption.name;
|
|
}
|
|
const activeOption2 = self.activeOption;
|
|
let name1;
|
|
if (null != activeOption2) {
|
|
name1 = activeOption2.name;
|
|
}
|
|
const tmp58 = name !== name1;
|
|
let tmp60 = tmp3;
|
|
if (!tmp3) {
|
|
tmp60 = tmp58;
|
|
}
|
|
if (!tmp60) {
|
|
tmp60 = tmp59;
|
|
}
|
|
if (tmp60) {
|
|
let preferredCommandType;
|
|
if (null != activeCommand) {
|
|
preferredCommandType = activeCommand.preferredCommandType;
|
|
}
|
|
tmp60 = preferredCommandType === constants2.FULL_COMMAND;
|
|
}
|
|
if (tmp60) {
|
|
self.optionValues = self.getAllCommandOptionValues(activeCommand, editId.text);
|
|
const obj7 = ApplicationCommandManager(tmp45[27]);
|
|
self.optionValidationResults = obj7.getValidationResults(activeCommand, self.optionValues, editId.channel.guild_id, editId.channel.id, false);
|
|
const chatInputNodes = self.chatInputNodes;
|
|
self.chatInputNodes = chatInputNodes.map((type) => {
|
|
if (type.type === self(tmp45[8]).ChatInputNodeType.COMMAND_OPTION) {
|
|
if (null != type.data) {
|
|
const option = type.data.option;
|
|
if (type.type === self(tmp45[8]).ChatInputNodeType.COMMAND_OPTION_WITH_VALUE) {
|
|
let name;
|
|
if (null != currentOption) {
|
|
name = currentOption.name;
|
|
}
|
|
if (option.name === name) {
|
|
if (tmp3) {
|
|
let obj = {};
|
|
const merged = Object.assign(type);
|
|
obj["style"] = undefined;
|
|
return obj;
|
|
}
|
|
}
|
|
}
|
|
obj = {};
|
|
const merged1 = Object.assign(type);
|
|
let name1;
|
|
if (null != currentOption) {
|
|
name1 = currentOption.name;
|
|
}
|
|
if (option.name !== name1) {
|
|
if (undefined !== tmp17) {
|
|
if (!tmp17.success) {
|
|
const styles = self.styles;
|
|
obj.style = styles.commandErrorOption();
|
|
}
|
|
let tmp21 = null != tmp17 && tmp17.success;
|
|
if (tmp21) {
|
|
tmp21 = option.type === self(tmp45[15]).ApplicationCommandOptionType.ATTACHMENT;
|
|
}
|
|
if (tmp21) {
|
|
obj = { action: "tapAttachment", channelId: type.channel.id, optionName: option.name };
|
|
obj.tapAction = obj;
|
|
obj.deleteNodeOnBackspace = true;
|
|
}
|
|
return obj;
|
|
}
|
|
}
|
|
const styles2 = self.styles;
|
|
obj.style = styles2.commandOption();
|
|
}
|
|
}
|
|
return type;
|
|
});
|
|
}
|
|
let tmp67 = tmp3;
|
|
if (!tmp3) {
|
|
tmp67 = tmp45;
|
|
}
|
|
if (!tmp67) {
|
|
tmp67 = tmp58;
|
|
}
|
|
if (!tmp67) {
|
|
tmp67 = editId !== editId.editId;
|
|
}
|
|
if (tmp67) {
|
|
const current = self.ref.current;
|
|
let result = current.updateNativeTextBlocksThrottled(self.chatInputNodes, editId.editId);
|
|
}
|
|
let tmp69 = tmp45;
|
|
if (tmp45) {
|
|
tmp69 = null != activeCommand;
|
|
}
|
|
if (tmp69) {
|
|
self.canAutoInsertFirstOption = true;
|
|
}
|
|
if (!obj8.isEmpty(self.optionsToNodes)) {
|
|
self.canAutoInsertFirstOption = false;
|
|
}
|
|
let preferredCommandType1;
|
|
if (null != activeCommand) {
|
|
preferredCommandType1 = activeCommand.preferredCommandType;
|
|
}
|
|
if (preferredCommandType1 !== constants2.FULL_COMMAND) {
|
|
let items = [];
|
|
} else {
|
|
items = undefined;
|
|
if (null != activeCommand) {
|
|
items = activeCommand.options;
|
|
}
|
|
}
|
|
const tmp75 = items.filter((required) => required.required).length > 0;
|
|
let preferredCommandType2;
|
|
if (null != activeCommand) {
|
|
preferredCommandType2 = activeCommand.preferredCommandType;
|
|
}
|
|
if (preferredCommandType2 !== constants2.FULL_COMMAND) {
|
|
let items1 = [];
|
|
} else {
|
|
items1 = undefined;
|
|
if (null != activeCommand) {
|
|
items1 = activeCommand.options;
|
|
}
|
|
}
|
|
const tmp79 = 1 === items1.filter((required) => !required.required).length;
|
|
let canAutoInsertFirstOption = self.canAutoInsertFirstOption;
|
|
if (canAutoInsertFirstOption) {
|
|
let preferredCommandType3;
|
|
if (null != activeCommand) {
|
|
preferredCommandType3 = activeCommand.preferredCommandType;
|
|
}
|
|
canAutoInsertFirstOption = preferredCommandType3 === constants2.FULL_COMMAND;
|
|
}
|
|
if (canAutoInsertFirstOption) {
|
|
canAutoInsertFirstOption = ApplicationCommandManager(tmp45[18]).isEmpty(self.optionsToNodes);
|
|
const obj9 = ApplicationCommandManager(tmp45[18]);
|
|
}
|
|
if (canAutoInsertFirstOption) {
|
|
canAutoInsertFirstOption = editId.text.length >= text.length;
|
|
}
|
|
if (canAutoInsertFirstOption) {
|
|
if (!self.insertFirstOptionIfValid(editId.text, activeCommand, activeCommand.displayName, tmp75, tmp79)) {
|
|
const result1 = self.insertFirstOptionIfValid(editId.text, activeCommand, activeCommand.untranslatedName, tmp75, tmp79);
|
|
}
|
|
}
|
|
if (tmp58) {
|
|
let type;
|
|
if (null != activeOption) {
|
|
type = activeOption.type;
|
|
}
|
|
if (type === ApplicationCommandManager(tmp45[15]).ApplicationCommandOptionType.ATTACHMENT) {
|
|
if (!self.optionValidationResults[activeOption.name].success) {
|
|
const current2 = self.ref.current;
|
|
let obj = { type: ApplicationCommandManager(tmp45[26]).KeyboardTypes.MEDIA };
|
|
obj = { target: constants.COMMAND, option: activeOption };
|
|
obj.context = obj;
|
|
current2.openCustomKeyboard(obj);
|
|
}
|
|
self.props = editId;
|
|
const obj1 = {};
|
|
preferredCommandType4 = undefined;
|
|
if (null != activeCommand) {
|
|
preferredCommandType4 = activeCommand.preferredCommandType;
|
|
}
|
|
preferredCommandType4 = constants2;
|
|
if (preferredCommandType4 === constants2.FULL_COMMAND) {
|
|
if (tmp58) {
|
|
preferredCommandType4 = null == activeCommand;
|
|
let arr5 = activeCommand;
|
|
if (!preferredCommandType4) {
|
|
let options = activeCommand.options;
|
|
preferredCommandType4 = null == options;
|
|
arr5 = options;
|
|
}
|
|
if (!preferredCommandType4) {
|
|
preferredCommandType4 = arr5.forEach((name) => {
|
|
name = name.name;
|
|
const obj = {};
|
|
name = undefined;
|
|
if (null != currentOption) {
|
|
name = currentOption.name;
|
|
}
|
|
obj.isActive = name === name;
|
|
obj.optionValue = self.optionValues[name];
|
|
let tmp3 = null != arr;
|
|
if (tmp3) {
|
|
tmp3 = arr.length > 0;
|
|
}
|
|
obj.hasValue = tmp3;
|
|
const optionsToNodes = self.optionsToNodes;
|
|
let value = optionsToNodes.get(name);
|
|
let _location;
|
|
if (null != value) {
|
|
_location = value.location;
|
|
}
|
|
obj.location = _location;
|
|
const optionsToNodes2 = self.optionsToNodes;
|
|
value = optionsToNodes2.get(name);
|
|
let length;
|
|
if (null != value) {
|
|
length = value.length;
|
|
}
|
|
obj.length = length;
|
|
obj1[name] = obj;
|
|
});
|
|
}
|
|
if (tmp58) {
|
|
if (null != activeOption) {
|
|
obj1[activeOption.name].hasValue = true;
|
|
}
|
|
if (null != self.activeOption) {
|
|
preferredCommandType4 = obj1[self.activeOption.name];
|
|
if (null != preferredCommandType4) {
|
|
if (preferredCommandType4.hasValue) {
|
|
obj1[self.activeOption.name].lastValidationResult = self.optionValidationResults[self.activeOption.name];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
preferredCommandType4 = self.getCurrentOption(true, editId.selectionStart);
|
|
if (tmp3) {
|
|
if (null != preferredCommandType4) {
|
|
const name2 = preferredCommandType4.name;
|
|
let obj2 = obj1[name2];
|
|
if (null == obj2) {
|
|
obj2 = {};
|
|
}
|
|
const optionsToNodes2 = self.optionsToNodes;
|
|
preferredCommandType4 = optionsToNodes2.get(name2);
|
|
preferredCommandType4 = undefined;
|
|
if (null != preferredCommandType4) {
|
|
preferredCommandType4 = preferredCommandType4.location;
|
|
}
|
|
obj2.location = preferredCommandType4;
|
|
const optionsToNodes3 = self.optionsToNodes;
|
|
let value = optionsToNodes3.get(name2);
|
|
preferredCommandType4 = undefined;
|
|
if (null != value) {
|
|
preferredCommandType4 = value.length;
|
|
}
|
|
obj2.length = preferredCommandType4;
|
|
obj2.optionValue = self.optionValues[name2];
|
|
obj2.hasValue = true;
|
|
obj1[name2] = obj2;
|
|
}
|
|
}
|
|
self.activeCommand = activeCommand;
|
|
self.activeCommandSection = tmp7;
|
|
self.activeOption = activeOption;
|
|
if (!tmp45) {
|
|
preferredCommandType4 = globalThis;
|
|
const _Object = Object;
|
|
tmp45 = Object.keys(obj1).length > 0;
|
|
}
|
|
if (!tmp45) {
|
|
tmp45 = flag;
|
|
}
|
|
if (tmp45) {
|
|
preferredCommandType4 = tmp3;
|
|
preferredCommandType4 = tmp45;
|
|
let obj3 = { channelId: editId.channel.id };
|
|
const activeCommand4 = self.activeCommand;
|
|
preferredCommandType4 = undefined;
|
|
if (null != activeCommand4) {
|
|
preferredCommandType4 = activeCommand4.preferredCommandType;
|
|
}
|
|
preferredCommandType4 = constants2;
|
|
preferredCommandType4 = null;
|
|
if (preferredCommandType4 === constants2.FULL_COMMAND) {
|
|
preferredCommandType4 = self.activeCommand;
|
|
}
|
|
obj3.command = preferredCommandType4;
|
|
const activeCommandSection = self.activeCommandSection;
|
|
preferredCommandType4 = null;
|
|
if (null != activeCommandSection) {
|
|
preferredCommandType4 = activeCommandSection;
|
|
}
|
|
obj3.section = preferredCommandType4;
|
|
const preferredCommand6 = self.preferredCommand;
|
|
preferredCommandType4 = undefined;
|
|
if (null != preferredCommand6) {
|
|
preferredCommandType4 = preferredCommand6.id;
|
|
}
|
|
preferredCommandType4 = null;
|
|
obj3.preferredCommandId = preferredCommandType4;
|
|
obj3.location = self.location;
|
|
obj3.changedOptionStates = obj1;
|
|
preferredCommandType4 = tmp3(tmp45[9]).updateChannelState(obj3);
|
|
const obj15 = tmp3(tmp45[9]);
|
|
}
|
|
}
|
|
}
|
|
preferredCommandType4 = tmp58;
|
|
if (tmp58) {
|
|
preferredCommandType4 = null != activeOption;
|
|
}
|
|
if (preferredCommandType4) {
|
|
preferredCommandType4 = ApplicationCommandManager;
|
|
preferredCommandType4 = tmp45;
|
|
preferredCommandType4 = activeOption.type !== ApplicationCommandManager(tmp45[15]).ApplicationCommandOptionType.ATTACHMENT;
|
|
}
|
|
if (preferredCommandType4) {
|
|
preferredCommandType4 = ApplicationCommandManager;
|
|
preferredCommandType4 = tmp45;
|
|
preferredCommandType4 = ApplicationCommandManager(tmp45[25]).getKeyboardType();
|
|
preferredCommandType4 = preferredCommandType4 !== ApplicationCommandManager(tmp45[26]).KeyboardTypes.SYSTEM;
|
|
const obj12 = ApplicationCommandManager(tmp45[25]);
|
|
}
|
|
if (preferredCommandType4) {
|
|
const current3 = self.ref.current;
|
|
preferredCommandType4 = current3.closeCustomKeyboard();
|
|
const current4 = self.ref.current;
|
|
preferredCommandType4 = current4.focus();
|
|
}
|
|
const obj8 = ApplicationCommandManager(tmp45[18]);
|
|
const tmp59 = lastCommandAutocompleteResponseNonce !== editId.lastCommandAutocompleteResponseNonce;
|
|
}
|
|
self.contextCommands = editId.queryCommands;
|
|
const preferredCommand = self.preferredCommand;
|
|
if (null != editId.preferredCommand) {
|
|
({ preferredCommand: self.preferredCommand, location: self.location } = editId);
|
|
}
|
|
if (editId.commandsDisabled) {
|
|
command = null;
|
|
if (null != null) {
|
|
({ command, section } = null);
|
|
}
|
|
const preferredCommand2 = self.preferredCommand;
|
|
let id2;
|
|
if (null != preferredCommand2) {
|
|
id2 = preferredCommand2.id;
|
|
}
|
|
let id3;
|
|
if (null != command) {
|
|
id3 = command.id;
|
|
}
|
|
if (id2 !== id3) {
|
|
if (tmp3) {
|
|
self.preferredCommand = null;
|
|
self.preferredCommandSection = null;
|
|
self.location = undefined;
|
|
}
|
|
} else {
|
|
const preferredCommand3 = self.preferredCommand;
|
|
let preferredCommandType5;
|
|
if (null != preferredCommand3) {
|
|
preferredCommandType5 = preferredCommand3.preferredCommandType;
|
|
}
|
|
let tmp15 = preferredCommandType5 === constants2.PARTIAL_COMMAND;
|
|
if (tmp15) {
|
|
let preferredCommandType6;
|
|
if (null != command) {
|
|
preferredCommandType6 = command.preferredCommandType;
|
|
}
|
|
tmp15 = preferredCommandType6 === constants2.FULL_COMMAND;
|
|
}
|
|
if (tmp15) {
|
|
self.preferredCommand = command;
|
|
}
|
|
}
|
|
let id4;
|
|
if (null != preferredCommand) {
|
|
id4 = preferredCommand.id;
|
|
}
|
|
const preferredCommand4 = self.preferredCommand;
|
|
let id5;
|
|
if (null != preferredCommand4) {
|
|
id5 = preferredCommand4.id;
|
|
}
|
|
let tmp20 = id4 !== id5;
|
|
if (!tmp20) {
|
|
let preferredCommandType7;
|
|
if (null != preferredCommand) {
|
|
preferredCommandType7 = preferredCommand.preferredCommandType;
|
|
}
|
|
const preferredCommand5 = self.preferredCommand;
|
|
let preferredCommandType8;
|
|
if (null != preferredCommand5) {
|
|
preferredCommandType8 = preferredCommand5.preferredCommandType;
|
|
}
|
|
tmp20 = preferredCommandType7 !== preferredCommandType8;
|
|
}
|
|
obj4 = self.preferredOptionValues[channel.id];
|
|
if (null == obj4) {
|
|
obj4 = {};
|
|
}
|
|
const parser = self.parser;
|
|
obj5 = {};
|
|
let preferredCommandType9;
|
|
if (null != command) {
|
|
preferredCommandType9 = command.preferredCommandType;
|
|
}
|
|
let tmp25 = null;
|
|
if (preferredCommandType9 === constants2.FULL_COMMAND) {
|
|
tmp25 = command;
|
|
}
|
|
obj5.activeCommand = tmp25;
|
|
obj5.preferredOptionValues = obj4;
|
|
self.chatInputNodes = parser.parse(editId.text, obj5);
|
|
const optionsToNodes = self.optionsToNodes;
|
|
optionsToNodes.clear();
|
|
const optionValueNodes = self.optionValueNodes;
|
|
optionValueNodes.clear();
|
|
const chatInputNodes1 = self.chatInputNodes;
|
|
const item = chatInputNodes1.forEach((type) => {
|
|
if (type.type === self(tmp45[8]).ChatInputNodeType.COMMAND_OPTION) {
|
|
const data = type.data;
|
|
type = undefined;
|
|
if (null != data) {
|
|
type = data.type;
|
|
}
|
|
if (type === self(tmp45[8]).ChatInputParseResultDataType.COMMAND_OPTION) {
|
|
const optionsToNodes = self.optionsToNodes;
|
|
const result = optionsToNodes.set(type.data.option.name, type);
|
|
}
|
|
}
|
|
let tmp5 = type.type === self(tmp45[8]).ChatInputNodeType.COMMAND_OPTION_WITH_VALUE;
|
|
if (tmp5) {
|
|
const data2 = type.data;
|
|
let type1;
|
|
if (null != data2) {
|
|
type1 = data2.type;
|
|
}
|
|
tmp5 = type1 === self(tmp45[8]).ChatInputParseResultDataType.COMMAND_OPTION;
|
|
}
|
|
if (tmp5) {
|
|
const optionValueNodes = self.optionValueNodes;
|
|
const result1 = optionValueNodes.set(type.data.option.name, type);
|
|
}
|
|
});
|
|
if (tmp3) {
|
|
const activeCommand2 = self.activeCommand;
|
|
let preferredCommandType10;
|
|
if (null != activeCommand2) {
|
|
preferredCommandType10 = activeCommand2.preferredCommandType;
|
|
}
|
|
if (preferredCommandType10 === constants2.FULL_COMMAND) {
|
|
const items2 = [];
|
|
const activeCommand5 = self.activeCommand;
|
|
options = undefined;
|
|
preferredCommandType4 = closure_15;
|
|
if (null != activeCommand5) {
|
|
options = activeCommand5.options;
|
|
}
|
|
if (null == options) {
|
|
options = [];
|
|
}
|
|
result = preferredCommandType4(options);
|
|
let iter = result();
|
|
if (!iter.done) {
|
|
do {
|
|
value = iter.value;
|
|
name = value.name;
|
|
let tmp32 = obj4[name];
|
|
let optionValueNodes2 = self.optionValueNodes;
|
|
value = optionValueNodes2.get(name);
|
|
let tmp33 = null == tmp32 || "" === tmp32.displayText;
|
|
if (!tmp33) {
|
|
let tmp34 = null != value;
|
|
if (tmp34) {
|
|
let str2 = editId.text;
|
|
tmp34 = str2.substring(value.location + value.displayName.length + 1, value.location + value.length) === tmp32.displayText;
|
|
}
|
|
tmp33 = tmp34;
|
|
}
|
|
if (!tmp33) {
|
|
delete r18[r27];
|
|
let tmp35 = closure_0;
|
|
let tmp36 = closure_3;
|
|
if (value.type === closure_0(closure_3[15]).ApplicationCommandOptionType.ATTACHMENT) {
|
|
let arr = items2.push(name);
|
|
}
|
|
}
|
|
iter2 = result();
|
|
iter = iter2;
|
|
} while (!iter2.done);
|
|
}
|
|
if (items2.length > 0) {
|
|
obj3 = editId(tmp45[24]);
|
|
obj3.removeFiles(channel.id, items2, closure_7.SlashCommand);
|
|
}
|
|
}
|
|
}
|
|
self.preferredOptionValues[channel.id] = obj4;
|
|
activeCommand = command;
|
|
tmp7 = section;
|
|
flag = tmp20;
|
|
} else {
|
|
if (!tmp3) {
|
|
if (null != self.preferredCommand) {
|
|
if (self.preferredCommand.preferredCommandType === constants2.FULL_COMMAND) {
|
|
let currentCommand = {};
|
|
({ preferredCommand: obj.command, preferredCommandSection: obj.section } = self);
|
|
}
|
|
}
|
|
}
|
|
currentCommand = self.getCurrentCommand(editId.text, editId.channel, self.preferredCommand, self.preferredCommandSection);
|
|
}
|
|
}
|
|
};
|
|
items[1] = obj;
|
|
obj = {
|
|
key: "updateValidationResults",
|
|
value: function updateValidationResults() {
|
|
const self = this;
|
|
const ApplicationCommandManager = this;
|
|
const obj = {};
|
|
const activeCommand = this.activeCommand;
|
|
let preferredCommandType;
|
|
if (null != activeCommand) {
|
|
preferredCommandType = activeCommand.preferredCommandType;
|
|
}
|
|
if (preferredCommandType === constants2.FULL_COMMAND) {
|
|
const activeCommand2 = self.activeCommand;
|
|
let tmp2 = null == activeCommand2;
|
|
let arr = activeCommand2;
|
|
if (!tmp2) {
|
|
const options = activeCommand2.options;
|
|
tmp2 = null == options;
|
|
arr = options;
|
|
}
|
|
if (!tmp2) {
|
|
const item = arr.forEach((name) => {
|
|
name = name.name;
|
|
const obj = { lastValidationResult: self.optionValidationResults[name] };
|
|
obj[name] = obj;
|
|
});
|
|
}
|
|
}
|
|
callback(closure_3[9]).updateOptionStates(self.props.channel.id, obj);
|
|
}
|
|
};
|
|
items[2] = obj;
|
|
return callback(ApplicationCommandManager, items);
|
|
}();
|
|
const result = arg1(dependencyMap[28]).fileFinishedImporting("modules/application_commands/native/ApplicationCommandManager.tsx");
|
|
|
|
export default tmp3;
|