alemonjs 2.1.79 → 2.1.80

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,8 +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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "alemonjs",
-  "version": "2.1.79",
+  "version": "2.1.80",
   "description": "bot script",
   "author": "lemonade",
   "license": "MIT",
@@ -34,7 +34,6 @@
     "cron": "^4.4.0",
     "file-type": "21.0.0",
     "flatted": "^3.3.3",
-    "https-proxy-agent": "^9.0.0",
     "koa": "^3.0.1",
     "koa-router": "^14.0.0",
     "koa-static": "^5.0.0",
@@ -44,6 +43,7 @@
     "qrcode": "^1.5.4",
     "uuid": "11.1.0",
     "ws": "^8.18.0",
+    "https-proxy-agent": "^9.0.0",
     "yaml": "^2.5.1"
   },
   "devDependencies": {
@@ -71,5 +71,5 @@
     "type": "git",
     "url": "https://github.com/lemonade-lab/alemonjs.git"
   },
-  "gitHead": "7dab16a2167bbdf5706931b67e7eab2fc67835d6"
-}
+  "gitHead": "c6aa5616afe091a37610dad22fbb2d2618d943b8"
+}

package/LICENSE

@@ -1,21 +0,0 @@
-The MIT License (MIT)
-
-Copyright (c) 2013-present, Yuxi (Evan) You
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIdED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.