Fix third party extension findings + enum provider - Allow extension names without the "third-party/" prefix - Expand enum provider to show what third-party extensions are

9fbcb1221020c9b3bfc81b9853c7ea7c1abab3ea

Wolfsblvt <wolfsblvt@gmail.com>

public/script.js+2 -2 Viewed

 import { initInputMarkdown } from './scripts/input-md-formatting.js';
 import { AbortReason } from './scripts/util/AbortReason.js';
 import { initSystemPrompts } from './scripts/sysprompt.js';
 import { registerExtensionSlashCommands as initExtensionSlashCommands } from './scripts/extensions-slashcommands.js';
 //exporting functions and vars for mods
 export {

     initLogprobs();
     initInputMarkdown();
     initExtensions();
     registerExtensionSlashCommandsinitExtensionSlashCommands();
     doDailyExtensionUpdatesCheck();
     await hideLoader();
     await fixViewport();

public/scripts/extensions-slashcommands.js+37 -11 Viewed

 import { ARGUMENT_TYPE, SlashCommandArgument, SlashCommandNamedArgument } from './slash-commands/SlashCommandArgument.js';
 import { SlashCommandClosure } from './slash-commands/SlashCommandClosure.js';
 import { commonEnumProviders } from './slash-commands/SlashCommandCommonEnumsProvider.js';
 import { enumTypes, SlashCommandEnumValue } from './slash-commands/SlashCommandEnumValue.js';
 import { SlashCommandParser } from './slash-commands/SlashCommandParser.js';
 import { equalsIgnoreCaseAndAccents, isFalseBoolean, isTrueBoolean } from './utils.js';

+        }
         const reload = isTrueBoolean(args?.reload);
         const internalExtensionName = extensionNames.find(x => equalsIgnoreCaseAndAccentsfindExtension(x, extensionName));
         if (!internalExtensionName) {
             toastr.warning(`Extension ${extensionName} does not exist.`);
             return '';

     };
+}
 +/**
 + * Finds an extension by name, allowing omission of the "third-party/" prefix.
 + *
 + * @param {string} name - The name of the extension to find
 + * @returns {string?} - The matched extension name or undefined if not found
 + */
 +function findExtension(name) {
 +    return extensionNames.find(extName => {
 +        return equalsIgnoreCaseAndAccents(extName, name) || equalsIgnoreCaseAndAccents(extName, `third-party/${name}`);
 +    });
 +}
++
 +/**
 + * Provides an array of SlashCommandEnumValue objects based on the extension names.
 + * Each object contains the name of the extension and a description indicating if it is a third-party extension.
 + *
 + * @returns {SlashCommandEnumValue[]} An array of SlashCommandEnumValue objects
 + */
 +const extensionNamesEnumProvider = () => extensionNames.map(name => {
 +    const isThirdParty = name.startsWith('third-party/');
 +    if (isThirdParty) name = name.slice('third-party/'.length);
++
 +    const description = isThirdParty ? 'third party extension' : null;
++
 +    return new SlashCommandEnumValue(name, description, !isThirdParty ? enumTypes.name : enumTypes.enum);
 +});
++
 export function registerExtensionSlashCommands() {
     SlashCommandParser.addCommandObject(SlashCommand.fromProps({
         name: 'extension-enable',

                 description: 'Extension name',
                 typeList: [ARGUMENT_TYPE.STRING],
                 isRequired: true,
 -                enumProvider: () => extensionNames.map(name => new SlashCommandEnumValue(name)),
 +                enumProvider: extensionNamesEnumProvider,
                 forceEnum: true,
             }),
         ],

                 description: 'Extension name',
                 typeList: [ARGUMENT_TYPE.STRING],
                 isRequired: true,
 -                enumProvider: () => extensionNames.map(name => new SlashCommandEnumValue(name)),
 +                enumProvider: extensionNamesEnumProvider,
                 forceEnum: true,
             }),
         ],

                 description: 'Extension name',
                 typeList: [ARGUMENT_TYPE.STRING],
                 isRequired: true,
 -                enumProvider: () => extensionNames.map(name => new SlashCommandEnumValue(name)),
 +                enumProvider: extensionNamesEnumProvider,
                 forceEnum: true,
             }),
         ],

         name: 'extension-state',
         callback: async (_, extensionName) => {
             if (typeof extensionName !== 'string') throw new Error('Extension name must be a string. Closures or arrays are not allowed.');
             const internalExtensionName = extensionNames.find(x => equalsIgnoreCaseAndAccentsfindExtension(x, extensionName));
             if (!internalExtensionName) {
                 toastr.warning(`Extension ${extensionName} does not exist.`);
                 return '';

                 description: 'Extension name',
                 typeList: [ARGUMENT_TYPE.STRING],
                 isRequired: true,
 -                enumProvider: () => extensionNames.map(name => new SlashCommandEnumValue(name)),
 +                enumProvider: extensionNamesEnumProvider,
                 forceEnum: true,
             }),
         ],

         aliases: ['extension-installed'],
         callback: async (_, extensionName) => {
             if (typeof extensionName !== 'string') throw new Error('Extension name must be a string. Closures or arrays are not allowed.');
             const exists = extensionNames.find(x => equalsIgnoreCaseAndAccentsfindExtension(x, extensionName)) !== undefined;
             return exists ? 'true' : 'false';
         },
         unnamedArgumentList: [

                 description: 'Extension name',
                 typeList: [ARGUMENT_TYPE.STRING],
                 isRequired: true,
 -                enumProvider: () => extensionNames.map(name => new SlashCommandEnumValue(name)),
 +                enumProvider: extensionNamesEnumProvider,
 -                forceEnum: true,
             }),
         ],
         helpString: `

                 <strong>Example:</strong>
                 <ul>
                     <li>
                         <pre><code class="language-stscript">/extension-exists SillyTavern-LALib</code></pre>
                     </li>
                 </ul>
             </div>