alemonjs 2.1.68 → 2.1.70

package/lib/app/router/dsl.js

@@ -0,0 +1,722 @@
+import { defineRouter } from '../define-router.js';
+import '../store.js';
+import '../../core/utils.js';
+import 'flatted';
+import 'fs';
+import 'path';
+import 'yaml';
+import '../../cbp/processor/config.js';
+import { Format } from '../message-format.js';
+import '../hook-event-context.js';
+import { useMessage } from '../hook-use/message.js';
+import '../message-format-old.js';
+import { checkFallbackHint } from './fallback.js';
+import { normalizeRoutePath, parseMessageText } from './parser.js';
+import { validateRouteArgsForCommand } from './validator.js';
+
+function normalizePathCondition(path) {
+    if (path === undefined) {
+        return undefined;
+    }
+    return normalizeRoutePath(path);
+}
+function mergeConditions(parent, current) {
+    const parentPath = normalizePathCondition(parent.path);
+    const currentPath = normalizePathCondition(current.path);
+    let path;
+    if (currentPath !== undefined) {
+        path = parentPath ? normalizeRoutePath(`${parentPath} ${currentPath}`) : currentPath;
+    }
+    else {
+        path = parentPath;
+    }
+    return {
+        path,
+        events: current.events ?? parent.events,
+        platforms: current.platforms ?? parent.platforms,
+        routeText: current.routeText ?? parent.routeText,
+        keyPolicy: current.keyPolicy ?? parent.keyPolicy,
+        duplicateKey: current.duplicateKey ?? parent.duplicateKey,
+        fallback: current.fallback ?? parent.fallback,
+        redispatch: current.redispatch ?? parent.redispatch
+    };
+}
+function normalizeRouteConfig(config) {
+    if (typeof config === 'string') {
+        return {
+            path: normalizeRoutePath(config)
+        };
+    }
+    const path = config.path;
+    if (!path) {
+        throw new Error('route path is required');
+    }
+    return {
+        path: normalizeRoutePath(path),
+        events: config.events,
+        platforms: config.platforms,
+        schema: config.schema
+    };
+}
+function normalizeResConfig(config, defaults) {
+    return {
+        events: defaults.events ?? config.events,
+        platforms: defaults.platforms ?? config.platforms,
+        regular: defaults.regular ?? config.regular
+    };
+}
+function getImporterLabel(importer, index) {
+    return importer.name || `anonymous_${index + 1}`;
+}
+function normalizeInteractionKey(messageText) {
+    return String(messageText ?? '')
+        .trim()
+        .replace(/^notAutoConfirmation:/, '');
+}
+function getEventPlatform(event) {
+    return typeof event.Platform === 'string' ? event.Platform : undefined;
+}
+function getPlatformRouteTextRule(routeText, platform) {
+    if (!routeText) {
+        return undefined;
+    }
+    if (platform && routeText.byPlatform?.[platform]) {
+        const platformRule = routeText.byPlatform[platform];
+        return {
+            prefixes: platformRule.prefixes ?? routeText.prefixes,
+            stripPrefix: platformRule.stripPrefix ?? routeText.stripPrefix,
+            allowBare: platformRule.allowBare ?? routeText.allowBare
+        };
+    }
+    return {
+        prefixes: routeText.prefixes,
+        stripPrefix: routeText.stripPrefix,
+        allowBare: routeText.allowBare
+    };
+}
+function normalizeScopedRouteText(messageText, routeText) {
+    const rawText = String(messageText ?? '').trim();
+    if (!rawText) {
+        return null;
+    }
+    if (!routeText?.prefixes?.length) {
+        return rawText;
+    }
+    const prefix = routeText.prefixes.find(item => rawText.startsWith(item));
+    if (!prefix) {
+        if (routeText.allowBare) {
+            return rawText;
+        }
+        return null;
+    }
+    if (!routeText.stripPrefix) {
+        return rawText;
+    }
+    const stripped = rawText.slice(prefix.length).trim();
+    return stripped || null;
+}
+function getRouteMessageText(event) {
+    const routeMessageText = event.__route?.text;
+    if (typeof routeMessageText === 'string' && routeMessageText.trim()) {
+        return routeMessageText;
+    }
+    return event.MessageText;
+}
+function getLookupCandidates(event, keyPolicy) {
+    const eventName = String(event.name ?? '');
+    const routeMessageText = getRouteMessageText(event);
+    if (eventName.includes('interaction')) {
+        const interactionKey = normalizeInteractionKey(routeMessageText);
+        if (!interactionKey) {
+            return null;
+        }
+        const underscoreIndex = interactionKey.indexOf('_');
+        const prefixKey = interactionKey.startsWith('select') ? 'select' : underscoreIndex > 0 ? interactionKey.slice(0, underscoreIndex) : interactionKey;
+        return {
+            normalizedCommand: interactionKey,
+            rawArgs: [],
+            candidates: [
+                { key: interactionKey, keyLength: 1 },
+                { key: prefixKey, keyLength: 1 }
+            ]
+        };
+    }
+    const parsed = parseMessageText(routeMessageText);
+    if (!parsed) {
+        return null;
+    }
+    const oneKey = parsed.tokens[0] ?? '';
+    const twoKey = parsed.tokens.length >= 2 ? `${parsed.tokens[0]} ${parsed.tokens[1]}` : '';
+    const maxWords = keyPolicy?.maxWords ?? 2;
+    const candidates = maxWords === 1
+        ? [{ key: oneKey, keyLength: 1 }]
+        : [
+            { key: twoKey, keyLength: 2 },
+            { key: oneKey, keyLength: 1 }
+        ];
+    return {
+        normalizedCommand: parsed.normalizedText,
+        rawArgs: parsed.tokens,
+        candidates
+    };
+}
+function buildRouteParams(route, parsedArgs) {
+    const params = {};
+    const args = route.config.schema?.args ?? [];
+    for (let index = 0; index < args.length; index += 1) {
+        params[args[index].name] = parsedArgs[index];
+    }
+    return params;
+}
+function attachRouteContext(event, context) {
+    event.__route = context;
+}
+function isOnResponseValue(value) {
+    return typeof value === 'object' && value !== null && 'current' in value;
+}
+function hasSelectValue(value) {
+    return typeof value === 'object' && value !== null && 'select' in value;
+}
+function isExecutable(value) {
+    return typeof value === 'function';
+}
+function unwrapImportedValue(value) {
+    if (typeof value === 'object' && value !== null && 'default' in value) {
+        return value.default;
+    }
+    return value;
+}
+function toExecutableList(value, eventName) {
+    const unwrapped = unwrapImportedValue(value);
+    if (eventName && hasSelectValue(unwrapped) && unwrapped.select) {
+        const selects = Array.isArray(unwrapped.select) ? unwrapped.select : [unwrapped.select];
+        if (!selects.includes(eventName)) {
+            return [];
+        }
+    }
+    if (isExecutable(unwrapped)) {
+        return [unwrapped];
+    }
+    if (!isOnResponseValue(unwrapped)) {
+        return [];
+    }
+    if (Array.isArray(unwrapped.current)) {
+        return unwrapped.current.filter(isExecutable);
+    }
+    return isExecutable(unwrapped.current) ? [unwrapped.current] : [];
+}
+class RouteGroup {
+    app;
+    middlewares;
+    options;
+    scopeId;
+    constructor(app, middlewares, options, scopeId) {
+        this.app = app;
+        this.middlewares = middlewares;
+        this.options = options;
+        this.scopeId = scopeId;
+    }
+    group(options, ...middlewares) {
+        return new RouteGroup(this.app, [...this.middlewares, ...middlewares], mergeConditions(this.options, options), this.scopeId);
+    }
+    use(config, ...importers) {
+        return this.app.register(config, [...this.middlewares, ...importers], this.options, this.scopeId);
+    }
+}
+class Router {
+    defaults;
+    globalImporters = [];
+    topLevelEntries = [];
+    scopes = new Map();
+    routes = new Map();
+    defaultScopeId;
+    constructor(options = {}) {
+        this.defaults = {
+            regular: options.regular,
+            events: options.events,
+            platforms: options.platforms
+        };
+    }
+    static create(options = {}) {
+        return new Router(options);
+    }
+    group(options, ...middlewares) {
+        const mergedOptions = mergeConditions({ events: this.defaults.events, platforms: this.defaults.platforms }, options);
+        const scopeId = this.createScope(mergedOptions);
+        return new RouteGroup(this, middlewares, mergedOptions, scopeId);
+    }
+    use(config, ...importers) {
+        const scopeId = this.ensureDefaultScope();
+        return this.register(config, importers, { events: this.defaults.events, platforms: this.defaults.platforms }, scopeId);
+    }
+    res(config, ...importers) {
+        const res = {
+            config: normalizeResConfig(config, this.defaults),
+            importers
+        };
+        this.globalImporters.push(res);
+        this.topLevelEntries.push({
+            kind: 'res',
+            res
+        });
+        return this.globalImporters;
+    }
+    register(config, importers, inheritedOptions, scopeId) {
+        if (Array.isArray(config)) {
+            return config.map(item => this.registerOne(item, importers, inheritedOptions, scopeId));
+        }
+        return this.registerOne(config, importers, inheritedOptions, scopeId);
+    }
+    registerOne(config, importers, inheritedOptions, scopeId) {
+        const normalized = normalizeRouteConfig(config);
+        const mergedOptions = mergeConditions(inheritedOptions, {
+            path: normalized.path,
+            events: normalized.events,
+            platforms: normalized.platforms
+        });
+        const fullPath = normalizePathCondition(mergedOptions.path) ?? '';
+        const events = mergedOptions.events ?? [];
+        const platforms = mergedOptions.platforms;
+        const tokenLength = fullPath.split(/\s+/).filter(Boolean).length;
+        const keyLength = tokenLength >= 2 ? 2 : 1;
+        if (events.length === 0) {
+            throw new Error(`route "${fullPath}" must declare events`);
+        }
+        const route = {
+            config: {
+                ...normalized,
+                path: fullPath,
+                events,
+                platforms
+            },
+            scopeId,
+            keyLength,
+            importers,
+            inheritedImporters: importers.slice(0, Math.max(importers.length - 1, 0))
+        };
+        for (const eventName of events) {
+            const routes = this.routes.get(eventName) ?? {
+                one: new Map(),
+                two: new Map()
+            };
+            const targetRoutes = keyLength === 2 ? routes.two : routes.one;
+            const existedRoute = targetRoutes.get(fullPath);
+            if (existedRoute) {
+                const duplicateMessage = `[router-map] 检测到重复指令注册: event=${eventName} path=${fullPath} oldScope=${existedRoute.scopeId} newScope=${scopeId}`;
+                const duplicateStrategy = mergedOptions.duplicateKey ?? 'warn';
+                if (duplicateStrategy === 'throw') {
+                    throw new Error(duplicateMessage);
+                }
+                if (duplicateStrategy === 'warn') {
+                    logger.warn(duplicateMessage);
+                }
+            }
+            targetRoutes.set(fullPath, route);
+            this.routes.set(eventName, routes);
+        }
+        return route;
+    }
+    inspect() {
+        return Array.from(this.routes.entries()).map(([eventName, routes]) => ({
+            eventName,
+            routes: [...routes.two.values(), ...routes.one.values()].map(route => ({
+                path: route.config.path,
+                importerCount: route.importers.length
+            }))
+        }));
+    }
+    get values() {
+        return [...this.buildTopLevelEntries(), this.buildFallbackEntry()];
+    }
+    get define() {
+        return defineRouter(this.values);
+    }
+    match(event, scopeId) {
+        const eventName = String(event.name ?? '');
+        const scope = scopeId ? this.scopes.get(scopeId) : undefined;
+        const lookup = getLookupCandidates(event, scope?.options.keyPolicy);
+        if (!eventName || !lookup) {
+            return { matched: false };
+        }
+        const routes = this.routes.get(eventName);
+        if (!routes) {
+            return { matched: false };
+        }
+        const candidates = lookup.candidates.map(candidate => ({
+            key: candidate.key,
+            route: candidate.keyLength === 2 ? routes.two.get(candidate.key) : routes.one.get(candidate.key)
+        }));
+        for (const candidate of candidates) {
+            const route = candidate.route;
+            if (!route) {
+                continue;
+            }
+            if (scopeId && route.scopeId !== scopeId) {
+                continue;
+            }
+            const platform = getEventPlatform(event);
+            if (route.config.platforms?.length && platform && !route.config.platforms.includes(platform)) {
+                continue;
+            }
+            const rawArgs = lookup.rawArgs.slice(route.keyLength);
+            const validation = validateRouteArgsForCommand(route.config.path, rawArgs, route.config.schema);
+            if (!validation.valid) {
+                return {
+                    matched: true,
+                    route,
+                    eventName,
+                    normalizedCommand: lookup.normalizedCommand,
+                    rawArgs,
+                    parsedArgs: [],
+                    validation,
+                    matchedPath: candidate.key,
+                    importerCount: route.importers.length,
+                    importerLabels: route.importers.map(getImporterLabel)
+                };
+            }
+            return {
+                matched: true,
+                route,
+                eventName,
+                normalizedCommand: lookup.normalizedCommand,
+                rawArgs,
+                parsedArgs: validation.parsedArgs,
+                validation,
+                matchedPath: candidate.key,
+                importerCount: route.importers.length,
+                importerLabels: route.importers.map(getImporterLabel)
+            };
+        }
+        return { matched: false };
+    }
+    dispatch(event, depth = 0) {
+        return this.dispatchInScope(event, undefined, depth);
+    }
+    async dispatchInScope(event, scopeId, depth = 0) {
+        const scope = scopeId ? this.scopes.get(scopeId) : undefined;
+        const maxRedispatchDepth = scope?.options.redispatch?.maxDepth ?? 3;
+        if (depth > maxRedispatchDepth) {
+            return {
+                matched: false,
+                stopped: true,
+                reason: 'redispatch_limit',
+                eventName: String(event.name ?? ''),
+                rawArgs: [],
+                parsedArgs: [],
+                importerCount: 0,
+                importerLabels: []
+            };
+        }
+        const match = this.match(event, scopeId);
+        if (!match.matched) {
+            return {
+                matched: false,
+                stopped: false,
+                reason: 'unmatched',
+                eventName: String(event.name ?? ''),
+                rawArgs: [],
+                parsedArgs: [],
+                importerCount: 0,
+                importerLabels: []
+            };
+        }
+        if (!match.validation.valid) {
+            attachRouteContext(event, {
+                key: match.route.config.path,
+                text: match.normalizedCommand,
+                rawArgs: match.rawArgs,
+                parsedArgs: [],
+                params: {}
+            });
+            return {
+                matched: true,
+                stopped: true,
+                reason: 'validation_failed',
+                eventName: match.eventName,
+                commandKey: match.route.config.path,
+                matchedPath: match.matchedPath,
+                normalizedCommand: match.normalizedCommand,
+                rawArgs: match.rawArgs,
+                parsedArgs: [],
+                params: {},
+                importerCount: match.importerCount,
+                importerLabels: match.importerLabels,
+                validation: match.validation
+            };
+        }
+        const initialMessageText = String(event.MessageText ?? '');
+        const params = buildRouteParams(match.route, match.parsedArgs);
+        attachRouteContext(event, {
+            key: match.route.config.path,
+            text: match.normalizedCommand,
+            rawArgs: match.rawArgs,
+            parsedArgs: match.parsedArgs,
+            params
+        });
+        const executed = await this.runImporters(match.route.importers, event, depth);
+        return {
+            matched: true,
+            stopped: executed.stopped,
+            reason: executed.reason,
+            eventName: match.eventName,
+            commandKey: match.route.config.path,
+            matchedPath: match.matchedPath,
+            normalizedCommand: match.normalizedCommand,
+            rawArgs: match.rawArgs,
+            parsedArgs: match.parsedArgs,
+            params,
+            importerCount: match.importerCount,
+            importerLabels: match.importerLabels,
+            validation: match.validation,
+            rewrittenMessageText: initialMessageText === String(event.MessageText ?? '') ? undefined : String(event.MessageText ?? '')
+        };
+    }
+    async handleScopeEvent(scopeId, event, next) {
+        const scope = this.scopes.get(scopeId);
+        const previousRoute = event.__route;
+        const platform = getEventPlatform(event);
+        const routeTextRule = getPlatformRouteTextRule(scope?.options.routeText, platform);
+        const scopedText = normalizeScopedRouteText(typeof event.MessageText === 'string' ? event.MessageText : undefined, routeTextRule);
+        if (routeTextRule && !scopedText) {
+            await next();
+            return;
+        }
+        if (scopedText) {
+            attachRouteContext(event, {
+                key: '',
+                text: scopedText,
+                rawArgs: [],
+                parsedArgs: [],
+                params: {}
+            });
+        }
+        const result = await this.dispatchInScope(event, scopeId);
+        if (!result.matched && result.reason === 'unmatched') {
+            if (previousRoute) {
+                event.__route = previousRoute;
+            }
+            else {
+                delete event.__route;
+            }
+            await next();
+            return;
+        }
+        this.replyValidationFailure(result);
+    }
+    async handleFallbackEvent(event, next) {
+        const applicableScopeIds = this.getApplicableScopeIds(event);
+        if (applicableScopeIds.length === 0) {
+            await next();
+            return;
+        }
+        const fallbackOptions = applicableScopeIds.map(scopeId => this.scopes.get(scopeId)?.options.fallback).find(Boolean) ?? {
+            suggest: true,
+            allowPrefixMatch: true
+        };
+        if (fallbackOptions.suggest === false) {
+            await next();
+            return;
+        }
+        const eventName = String(event.name ?? '');
+        const routeKeys = this.inspect()
+            .filter(item => item.eventName === eventName)
+            .flatMap(item => item.routes)
+            .filter(route => {
+            const routeEntry = this.routes.get(eventName)?.one.get(route.path) ?? this.routes.get(eventName)?.two.get(route.path);
+            return routeEntry ? applicableScopeIds.includes(routeEntry.scopeId) : false;
+        })
+            .map(route => route.path);
+        const fallback = checkFallbackHint(typeof event.MessageText === 'string' ? event.MessageText : undefined, routeKeys, fallbackOptions);
+        if (!fallback.matched) {
+            await next();
+            return;
+        }
+        const [message] = useMessage();
+        const md = Format.createMarkdown();
+        const format = Format.create();
+        md.addText(fallback.message ?? '未匹配到可用指令');
+        format.addMarkdown(md);
+        void message.send({ format });
+    }
+    replyValidationFailure(result) {
+        if (result.reason !== 'validation_failed') {
+            return;
+        }
+        const validation = result.validation;
+        const [message] = useMessage();
+        const md = Format.createMarkdown();
+        const format = Format.create();
+        md.addText(validation && !validation.valid ? validation.error : '参数校验失败');
+        if (validation && !validation.valid && validation.usage) {
+            md.addNewline();
+            md.addText(`应使用：${validation.usage}`);
+        }
+        else if (result.commandKey) {
+            md.addNewline();
+            md.addText(`请补全 \`${result.commandKey}\` 所需参数。`);
+        }
+        format.addMarkdown(md);
+        void message.send({ format });
+    }
+    buildTopLevelEntries() {
+        return this.topLevelEntries.flatMap(item => (item.kind === 'res' ? this.buildResEntriesFor(item.res) : this.buildScopeEntriesFor(item.scopeId)));
+    }
+    buildResEntriesFor(item) {
+        const eventNames = item.config.events ?? [];
+        const regular = item.config.regular;
+        const platforms = item.config.platforms;
+        return item.importers
+            .map(importer => {
+            const base = {
+                selects: eventNames,
+                regular,
+                handler: async () => unwrapImportedValue(await importer())
+            };
+            if (!platforms?.length) {
+                return base;
+            }
+            return {
+                ...base,
+                platform: [...platforms]
+            };
+        })
+            .flat();
+    }
+    buildScopeEntriesFor(scopeId) {
+        const scope = this.scopes.get(scopeId);
+        if (!scope) {
+            return [];
+        }
+        const selects = (scope.options.events ?? this.defaults.events ?? Array.from(this.routes.keys()));
+        const platforms = scope.options.platforms;
+        const base = {
+            selects,
+            handler: () => {
+                return Promise.resolve(async (event, next) => {
+                    await this.handleScopeEvent(scopeId, event, next);
+                });
+            }
+        };
+        if (!platforms?.length) {
+            return [base];
+        }
+        return [
+            {
+                ...base,
+                platform: [...platforms]
+            }
+        ];
+    }
+    buildFallbackEntry() {
+        const defaultEvents = this.defaults.events ?? [];
+        const eventNames = Array.from(new Set([...defaultEvents, ...Array.from(this.routes.keys())]));
+        return {
+            selects: eventNames,
+            handler: () => {
+                return Promise.resolve(async (event, next) => {
+                    await this.handleFallbackEvent(event, next);
+                });
+            }
+        };
+    }
+    ensureDefaultScope() {
+        if (this.defaultScopeId) {
+            return this.defaultScopeId;
+        }
+        this.defaultScopeId = this.createScope({
+            events: this.defaults.events,
+            platforms: this.defaults.platforms
+        });
+        return this.defaultScopeId;
+    }
+    createScope(options) {
+        const id = `scope_${this.topLevelEntries.filter(item => item.kind === 'scope').length + 1}`;
+        this.scopes.set(id, {
+            id,
+            options
+        });
+        this.topLevelEntries.push({
+            kind: 'scope',
+            scopeId: id
+        });
+        return id;
+    }
+    getApplicableScopeIds(event) {
+        const eventName = String(event.name ?? '');
+        const platform = getEventPlatform(event);
+        const messageText = typeof event.MessageText === 'string' ? event.MessageText : undefined;
+        return this.topLevelEntries
+            .filter((item) => item.kind === 'scope')
+            .map(item => item.scopeId)
+            .filter(scopeId => {
+            const scope = this.scopes.get(scopeId);
+            if (!scope) {
+                return false;
+            }
+            if (scope.options.events?.length && !scope.options.events.includes(eventName)) {
+                return false;
+            }
+            if (scope.options.platforms?.length && platform && !scope.options.platforms.includes(platform)) {
+                return false;
+            }
+            const routeTextRule = getPlatformRouteTextRule(scope.options.routeText, platform);
+            if (!routeTextRule) {
+                return true;
+            }
+            return Boolean(normalizeScopedRouteText(messageText, routeTextRule));
+        });
+    }
+    runImporters(importers, event, depth) {
+        const visit = async (index) => {
+            if (index >= importers.length) {
+                return { stopped: false, reason: 'handler_completed' };
+            }
+            const beforeMessageText = String(event.MessageText ?? '');
+            const imported = await importers[index]();
+            const executableList = toExecutableList(imported, typeof event.name === 'string' ? event.name : undefined);
+            if (executableList.length === 0) {
+                return { stopped: true, reason: 'unsupported_handler' };
+            }
+            let downstreamRequested = false;
+            let downstreamResult = null;
+            const next = async () => {
+                downstreamRequested = true;
+                downstreamResult = await visit(index + 1);
+            };
+            for (const executable of executableList) {
+                const result = await executable(event, next);
+                if (downstreamRequested) {
+                    if (downstreamResult) {
+                        return downstreamResult;
+                    }
+                    break;
+                }
+                if (result === false) {
+                    return { stopped: true, reason: 'handler_returned_false' };
+                }
+                if (result === true) {
+                    continue;
+                }
+                return { stopped: true, reason: 'handler_completed' };
+            }
+            if (downstreamRequested) {
+                if (downstreamResult) {
+                    return downstreamResult;
+                }
+                const afterMessageText = String(event.MessageText ?? '');
+                if (index === importers.length - 1 && afterMessageText && afterMessageText !== beforeMessageText) {
+                    const redispatched = await this.dispatch(event, depth + 1);
+                    return {
+                        stopped: redispatched.stopped,
+                        reason: redispatched.reason
+                    };
+                }
+                return { stopped: false, reason: 'handler_completed' };
+            }
+            return await visit(index + 1);
+        };
+        return visit(0);
+    }
+}
+
+export { Router };