@sapphire/framework
Version:
Discord bot framework built for advanced and amazing bots.
180 lines (178 loc) • 8.79 kB
JavaScript
;
const require_lib_utils_application_commands_compute_differences__shared = require('./_shared.cjs');
const require_lib_utils_application_commands_compute_differences_description = require('./description.cjs');
const require_lib_utils_application_commands_compute_differences_localizations = require('./localizations.cjs');
const require_lib_utils_application_commands_compute_differences_name = require('./name.cjs');
const require_lib_utils_application_commands_compute_differences_option_autocomplete = require('./option/autocomplete.cjs');
const require_lib_utils_application_commands_compute_differences_option_channelTypes = require('./option/channelTypes.cjs');
const require_lib_utils_application_commands_compute_differences_option_minMaxLength = require('./option/minMaxLength.cjs');
const require_lib_utils_application_commands_compute_differences_option_minMaxValue = require('./option/minMaxValue.cjs');
const require_lib_utils_application_commands_compute_differences_option_required = require('./option/required.cjs');
const require_lib_utils_application_commands_compute_differences_option_type = require('./option/type.cjs');
let discord_api_types_v10 = require("discord-api-types/v10");
//#region src/lib/utils/application-commands/compute-differences/options.ts
function* checkOptions(existingOptions, newOptions) {
if (!existingOptions?.length && newOptions?.length) yield {
key: "options",
original: "no options present",
expected: "options present"
};
else if (existingOptions?.length && !newOptions?.length) yield {
key: "options",
original: "options present",
expected: "no options present"
};
else if (newOptions?.length) {
let index = 0;
for (const option of newOptions) {
const currentIndex = index++;
const existingOption = existingOptions[currentIndex];
yield* reportOptionDifferences({
currentIndex,
option,
existingOption
});
}
if (index < existingOptions.length) {
let option;
while ((option = existingOptions[index]) !== void 0) {
const expectedType = require_lib_utils_application_commands_compute_differences__shared.optionTypeToPrettyName.get(option.type) ?? `unknown (${option.type}); please contact Sapphire developers about this!`;
yield {
key: `existing command option at index ${index}`,
expected: "no option present",
original: `${expectedType} with name ${option.name}`
};
index++;
}
}
}
}
function* reportOptionDifferences({ option, existingOption, currentIndex, keyPath = (index) => `options[${index}]` }) {
if (!existingOption) {
const expectedType = require_lib_utils_application_commands_compute_differences__shared.optionTypeToPrettyName.get(option.type) ?? `unknown (${option.type}); please contact Sapphire developers about this!`;
yield {
key: keyPath(currentIndex),
expected: `${expectedType} with name ${option.name}`,
original: "no option present"
};
return;
}
yield* require_lib_utils_application_commands_compute_differences_option_type.checkOptionType({
key: `${keyPath(currentIndex)}.type`,
originalType: existingOption.type,
expectedType: option.type
});
yield* require_lib_utils_application_commands_compute_differences_name.checkName({
key: `${keyPath(currentIndex)}.name`,
oldName: existingOption.name,
newName: option.name
});
const originalLocalizedNames = existingOption.name_localizations;
const expectedLocalizedNames = option.name_localizations;
yield* require_lib_utils_application_commands_compute_differences_localizations.checkLocalizations({
localeMapName: `${keyPath(currentIndex)}.nameLocalizations`,
localePresentMessage: "localized names",
localeMissingMessage: "no localized names",
originalLocalizedDescriptions: originalLocalizedNames,
expectedLocalizedDescriptions: expectedLocalizedNames
});
yield* require_lib_utils_application_commands_compute_differences_description.checkDescription({
key: `${keyPath(currentIndex)}.description`,
oldDescription: existingOption.description,
newDescription: option.description
});
const originalLocalizedDescriptions = existingOption.description_localizations;
const expectedLocalizedDescriptions = option.description_localizations;
yield* require_lib_utils_application_commands_compute_differences_localizations.checkLocalizations({
localeMapName: `${keyPath(currentIndex)}.descriptionLocalizations`,
localePresentMessage: "localized descriptions",
localeMissingMessage: "no localized descriptions",
originalLocalizedDescriptions,
expectedLocalizedDescriptions
});
yield* require_lib_utils_application_commands_compute_differences_option_required.checkOptionRequired({
key: `${keyPath(currentIndex)}.required`,
oldRequired: existingOption.required,
newRequired: option.required
});
if (require_lib_utils_application_commands_compute_differences__shared.subcommandTypes.includes(existingOption.type) && require_lib_utils_application_commands_compute_differences__shared.subcommandTypes.includes(option.type)) {
const castedExisting = existingOption;
const castedExpected = option;
if (castedExisting.type === discord_api_types_v10.ApplicationCommandOptionType.SubcommandGroup && castedExpected.type === discord_api_types_v10.ApplicationCommandOptionType.SubcommandGroup) for (const [subcommandIndex, subcommandOption] of castedExpected.options.entries()) yield* reportOptionDifferences({
currentIndex: subcommandIndex,
option: subcommandOption,
existingOption: castedExisting.options?.[subcommandIndex],
keyPath: (index) => `${keyPath(currentIndex)}.options[${index}]`
});
else if (castedExisting.type === discord_api_types_v10.ApplicationCommandOptionType.Subcommand && castedExpected.type === discord_api_types_v10.ApplicationCommandOptionType.Subcommand) yield* handleSubcommandOptions({
expectedOptions: castedExpected.options,
existingOptions: castedExisting.options,
currentIndex,
keyPath
});
}
if (require_lib_utils_application_commands_compute_differences__shared.hasMinMaxValueSupport(option)) yield* require_lib_utils_application_commands_compute_differences_option_minMaxValue.handleMinMaxValueOptions({
currentIndex,
existingOption,
expectedOption: option,
keyPath
});
if (require_lib_utils_application_commands_compute_differences__shared.hasChoicesAndAutocompleteSupport(option)) yield* require_lib_utils_application_commands_compute_differences_option_autocomplete.handleAutocomplete({
expectedOption: option,
existingOption,
currentIndex,
keyPath
});
if (require_lib_utils_application_commands_compute_differences__shared.hasMinMaxLengthSupport(option)) yield* require_lib_utils_application_commands_compute_differences_option_minMaxLength.handleMinMaxLengthOptions({
currentIndex,
existingOption,
expectedOption: option,
keyPath
});
if (require_lib_utils_application_commands_compute_differences__shared.hasChannelTypesSupport(option)) yield* require_lib_utils_application_commands_compute_differences_option_channelTypes.checkChannelTypes({
currentIndex,
existingChannelTypes: existingOption.channel_types,
keyPath,
newChannelTypes: option.channel_types
});
}
function* handleSubcommandOptions({ expectedOptions, existingOptions, currentIndex, keyPath }) {
if (!existingOptions?.length && expectedOptions?.length) yield {
key: `${keyPath(currentIndex)}.options`,
expected: "options present",
original: "no options present"
};
else if (existingOptions?.length && !expectedOptions?.length) yield {
key: `${keyPath(currentIndex)}.options`,
expected: "no options present",
original: "options present"
};
else if (expectedOptions?.length) {
let processedIndex = 0;
for (const subcommandOption of expectedOptions) {
const currentSubCommandOptionIndex = processedIndex++;
const existingSubcommandOption = existingOptions[currentSubCommandOptionIndex];
yield* reportOptionDifferences({
currentIndex: currentSubCommandOptionIndex,
option: subcommandOption,
existingOption: existingSubcommandOption,
keyPath: (index) => `${keyPath(currentIndex)}.options[${index}]`
});
}
if (processedIndex < existingOptions.length) {
let option;
while ((option = existingOptions[processedIndex]) !== void 0) {
const expectedType = require_lib_utils_application_commands_compute_differences__shared.optionTypeToPrettyName.get(option.type) ?? `unknown (${option.type}); please contact Sapphire developers about this!`;
yield {
key: `existing command option at path ${keyPath(currentIndex)}.options[${processedIndex}]`,
expected: "no option present",
original: `${expectedType} with name ${option.name}`
};
processedIndex++;
}
}
}
}
//#endregion
exports.checkOptions = checkOptions;
//# sourceMappingURL=options.cjs.map