alemonjs 2.1.78 → 2.1.80

package/lib/app/event-processor.js

@@ -146,6 +146,8 @@ const onProcessor = (name, event, data) => {
                 event['value'] = data;
             }
             event['name'] = name;
+            event['IsPrivate'] = event['IsPrivate'] ?? name.startsWith('private.');
+            event['IsAtMe'] = event['IsAtMe'] ?? false;
             expendCycle(event, name, value);
         }
         catch (error) {

package/lib/app/hook-event-context.js

@@ -96,29 +96,41 @@ const finishCurrentTrace = (reason) => {
 const getTargetEvent = (event) => {
     return event ?? eventStore.getStore()?.event;
 };
+const setSendAttempted = (target) => {
+    target._sendAttempted = true;
+    target._has_send_attempt = true;
+};
+const setSendSucceeded = (target) => {
+    target._sendSucceeded = true;
+    target._has_send_success = true;
+};
+const setLastSendError = (target, error) => {
+    target._lastSendError = error;
+    target._last_send_error = error;
+};
 const markEventSendAttempt = (event) => {
     const target = getTargetEvent(event);
     if (!target) {
         return;
     }
-    target._has_send_attempt = true;
+    setSendAttempted(target);
 };
 const markEventSendSuccess = (event) => {
     const target = getTargetEvent(event);
     if (!target) {
         return;
     }
-    target._has_send_attempt = true;
-    target._has_send_success = true;
-    target._last_send_error = null;
+    setSendAttempted(target);
+    setSendSucceeded(target);
+    setLastSendError(target, null);
 };
 const markEventSendFailure = (error, event) => {
     const target = getTargetEvent(event);
     if (!target) {
         return;
     }
-    target._has_send_attempt = true;
-    target._last_send_error = error instanceof Error ? error.message : typeof error === 'string' ? error : 'Unknown send error';
+    setSendAttempted(target);
+    setLastSendError(target, error instanceof Error ? error.message : typeof error === 'string' ? error : 'Unknown send error');
 };
 const recordEventSendResults = (results, event) => {
     markEventSendAttempt(event);

package/lib/app/hook-use/index.d.ts

@@ -12,6 +12,7 @@ export * from './permission';
 export * from './reaction';
 export * from './request';
 export * from './role';
+export * from './route';
 export * from './user';
 export * from './subscribe';
 export * from './event';

package/lib/app/hook-use/index.js

@@ -12,6 +12,7 @@ export { usePermission } from './permission.js';
 export { useReaction } from './reaction.js';
 export { useRequest } from './request.js';
 export { useRole } from './role.js';
+export { useRoute } from './route.js';
 export { useUser } from './user.js';
 export { useObserver, useSubscribe } from './subscribe.js';
 export { createEvent, useEvent } from './event.js';

package/lib/app/hook-use/route.d.ts

@@ -0,0 +1,32 @@
+import type { EventKeys, Events } from '../../types';
+import type { RouteParams } from '../router/types';
+import type { RouteSchemaValue } from '../router/validator';
+type RouteReader = {
+    param: (name: string) => RouteSchemaValue | undefined;
+    hasParam: (name: string) => boolean;
+};
+export type UseRouteUnmatched = RouteReader & {
+    matched: false;
+    key: undefined;
+    text: undefined;
+    sourceText: undefined;
+    rewrittenText: undefined;
+    rawArgs: [];
+    parsedArgs: [];
+    params: {
+        [key: string]: any;
+    };
+};
+export type UseRouteMatched = RouteReader & {
+    matched: true;
+    key: string;
+    text: string;
+    sourceText?: string;
+    rewrittenText: string;
+    rawArgs: string[];
+    parsedArgs: RouteSchemaValue[];
+    params: RouteParams;
+};
+export type UseRouteResult = UseRouteUnmatched | UseRouteMatched;
+export declare const useRoute: <T extends EventKeys>(event?: Events[T]) => readonly [UseRouteResult];
+export {};

package/lib/app/hook-use/route.js

@@ -0,0 +1,39 @@
+import { getEventOrThrow } from './common.js';
+
+const createRouteReader = (params) => ({
+    param: (name) => params[name],
+    hasParam: (name) => Object.prototype.hasOwnProperty.call(params, name) && params[name] !== undefined
+});
+const createEmptyRoute = () => ({
+    matched: false,
+    key: undefined,
+    text: undefined,
+    sourceText: undefined,
+    rewrittenText: undefined,
+    rawArgs: [],
+    parsedArgs: [],
+    params: {},
+    ...createRouteReader({})
+});
+const useRoute = (event) => {
+    const currentEvent = getEventOrThrow(event);
+    const route = currentEvent.__route;
+    if (!route) {
+        return [createEmptyRoute()];
+    }
+    return [
+        {
+            matched: true,
+            key: route.key,
+            text: route.text,
+            sourceText: route.sourceText,
+            rewrittenText: route.rewrittenText ?? route.text,
+            rawArgs: [...route.rawArgs],
+            parsedArgs: [...route.parsedArgs],
+            params: { ...route.params },
+            ...createRouteReader(route.params)
+        }
+    ];
+};
+
+export { useRoute };

package/lib/app/index.js

@@ -30,6 +30,7 @@ export { usePermission } from './hook-use/permission.js';
 export { useReaction } from './hook-use/reaction.js';
 export { useRequest } from './hook-use/request.js';
 export { useRole } from './hook-use/role.js';
+export { useRoute } from './hook-use/route.js';
 export { useUser } from './hook-use/user.js';
 export { useObserver, useSubscribe } from './hook-use/subscribe.js';
 export { createEvent, useEvent } from './hook-use/event.js';

package/lib/app/router/dsl.js

@@ -545,6 +545,8 @@ class Router {
             attachRouteContext(event, {
                 key: match.route.config.path,
                 text: match.normalizedCommand,
+                sourceText: typeof event.MessageText === 'string' ? event.MessageText : undefined,
+                rewrittenText: match.normalizedCommand,
                 rawArgs: match.rawArgs,
                 parsedArgs: [],
                 params: {}
@@ -570,6 +572,8 @@ class Router {
         attachRouteContext(event, {
             key: match.route.config.path,
             text: match.normalizedCommand,
+            sourceText: initialMessageText,
+            rewrittenText: match.normalizedCommand,
             rawArgs: match.rawArgs,
             parsedArgs: match.parsedArgs,
             params
@@ -606,6 +610,8 @@ class Router {
             attachRouteContext(event, {
                 key: '',
                 text: scopedText,
+                sourceText: typeof event.MessageText === 'string' ? event.MessageText : undefined,
+                rewrittenText: scopedText,
                 rawArgs: [],
                 parsedArgs: [],
                 params: {}

package/lib/app/router/types.d.ts

@@ -3,6 +3,8 @@ export type RouteParams = Record<string, RouteSchemaValue | undefined>;
 export type RouteContext = {
     key: string;
     text: string;
+    sourceText?: string;
+    rewrittenText?: string;
     rawArgs: string[];
     parsedArgs: RouteSchemaValue[];
     params: RouteParams;

package/lib/index.js

@@ -37,6 +37,7 @@ export { usePermission } from './app/hook-use/permission.js';
 export { useReaction } from './app/hook-use/reaction.js';
 export { useRequest } from './app/hook-use/request.js';
 export { useRole } from './app/hook-use/role.js';
+export { useRoute } from './app/hook-use/route.js';
 export { useUser } from './app/hook-use/user.js';
 export { useObserver, useSubscribe } from './app/hook-use/subscribe.js';
 export { createEvent, useEvent } from './app/hook-use/event.js';

package/lib/types/event/base/expansion.d.ts

@@ -1,6 +1,11 @@
 export type Expansion = {
+    IsAtMe?: boolean;
+    IsPrivate?: boolean;
+    _sendAttempted?: boolean;
     _has_send_attempt?: boolean;
+    _sendSucceeded?: boolean;
     _has_send_success?: boolean;
+    _lastSendError?: string | null;
     _last_send_error?: string | null;
     [key: string]: any;
 };

package/lib/types/event/base/platform.d.ts

@@ -2,4 +2,6 @@ export type Platform = {
     Platform: string;
     value: any;
     BotId?: string;
+    IsAtMe?: boolean;
+    IsPrivate?: boolean;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "alemonjs",
-  "version": "2.1.78",
+  "version": "2.1.80",
   "description": "bot script",
   "author": "lemonade",
   "license": "MIT",