@koishijs/core - npm Package Compare versions

Comparing version 4.9.6 to 4.9.7

lib/index.d.ts

@@ -0,18 +1,30 @@
+/// <reference types="node" />
 import * as utils from '@koishijs/utils';
-import * as satori from '@satorijs/core';
 import * as cordis from 'cordis';
-import { Dict, Awaitable, Schema, Logger, Promisify } from '@koishijs/utils';
+import { Dict, Awaitable, Promisify } from 'cosmokit';
 import { Database, Driver, Result, Update } from '@minatojs/core';
-import { segment } from '@satorijs/core';
+import { Context, Fragment, segment, Session, Schema, Events, Logger } from '@satorijs/core';
 import { Disposable, GetEvents, Parameters, ReturnType, ThisType } from 'cordis';
 import { version } from '../package.json';
-export interface Events {
-    'model'(name: keyof Tables): void;
+declare module '@satorijs/core' {
+    interface Bot {
+        getGuildMemberMap(guildId: string): Promise<Dict<string>>;
+        broadcast(channels: (string | [string, string])[], content: Fragment, delay?: number): Promise<string[]>;
+    }
+    interface Events {
+        'appellation'(name: string, session: Session): string;
+    }
 }
-export interface Context {
-    database: DatabaseService;
-    model: DatabaseService;
-    getSelfIds(type?: string, assignees?: string[]): Dict<string[]>;
-    broadcast(content: string | segment, forced?: boolean): Promise<string[]>;
-    broadcast(channels: readonly string[], content: string | segment, forced?: boolean): Promise<string[]>;
+export * from '@satorijs/core';
+declare module '@satorijs/core' {
+    interface Events {
+        'model'(name: keyof Tables): void;
+    }
+    interface Context {
+        database: DatabaseService;
+        model: DatabaseService;
+        getSelfIds(type?: string, assignees?: string[]): Dict<string[]>;
+        broadcast(content: Fragment, forced?: boolean): Promise<string[]>;
+        broadcast(channels: readonly string[], content: Fragment, forced?: boolean): Promise<string[]>;
+    }
 }
@@ -69,25 +81,27 @@ export interface User {
     createChannel(platform: string, id: string, data: Partial<Channel>): Promise<Channel>;
-    broadcast(...args: [string | segment, boolean?] | [readonly string[], string | segment, boolean?]): Promise<any[]>;
+    broadcast(...args: [Fragment, boolean?] | [readonly string[], Fragment, boolean?]): Promise<any[]>;
 }
 export const defineDriver: <T>(constructor: Driver.Constructor<T>, schema?: utils.Schema, prepare?: Plugin.Function<T>) => Plugin.Object<T, any>;
-export interface Context {
-    $internal: Internal;
-    middleware(middleware: Middleware, prepend?: boolean): () => boolean;
+declare module '@satorijs/core' {
+    interface Context {
+        $internal: Internal;
+        middleware(middleware: Middleware, prepend?: boolean): () => boolean;
+    }
+    interface Events {
+        'before-attach-channel'(session: Session, fields: Set<Channel.Field>): void;
+        'attach-channel'(session: Session): Awaitable<void | boolean>;
+        'before-attach-user'(session: Session, fields: Set<User.Field>): void;
+        'attach-user'(session: Session): Awaitable<void | boolean>;
+        'before-attach'(session: Session): void;
+        'attach'(session: Session): void;
+        'middleware'(session: Session): void;
+    }
 }
-export interface Events {
-    'before-attach-channel'(session: Session, fields: Set<Channel.Field>): void;
-    'attach-channel'(session: Session): Awaitable<void | boolean>;
-    'before-attach-user'(session: Session, fields: Set<User.Field>): void;
-    'attach-user'(session: Session): Awaitable<void | boolean>;
-    'before-attach'(session: Session): void;
-    'attach'(session: Session): void;
-    'middleware'(session: Session): void;
-}
-export type Next = (next?: Next.Callback) => Promise<void | string | segment>;
-export type Middleware = (session: Session, next: Next) => Awaitable<void | string | segment>;
+export type Next = (next?: Next.Callback) => Promise<void | Fragment>;
+export type Middleware = (session: Session, next: Next) => Awaitable<void | Fragment>;
 export namespace Next {
     const MAX_DEPTH = 64;
-    type Queue = ((next?: Next) => Awaitable<void | string | segment>)[];
-    type Callback = void | string | ((next?: Next) => Awaitable<void | string | segment>);
-    function compose(callback: Callback, next?: Next): Promise<string | void | segment>;
+    type Queue = ((next?: Next) => Awaitable<void | Fragment>)[];
+    type Callback = void | string | ((next?: Next) => Awaitable<void | Fragment>);
+    function compose(callback: Callback, next?: Next): Promise<void | segment.Fragment>;
 }
@@ -138,3 +152,3 @@ export namespace Internal {
 }
-export interface Argv<U extends User.Field = never, G extends Channel.Field = never, A extends any[] = any[], O = {}> {
+export interface Argv<U extends User.Field = never, G extends Channel.Field = never, A extends any[] = any[], O extends {} = {}> {
     args?: A;
@@ -263,3 +277,3 @@ options?: O;
     }
-    type Action<U extends User.Field = never, G extends Channel.Field = never, A extends any[] = any[], O extends {} = {}> = (argv: Argv<U, G, A, O>, ...args: A) => Awaitable<void | string | segment>;
+    type Action<U extends User.Field = never, G extends Channel.Field = never, A extends any[] = any[], O extends {} = {}> = (argv: Argv<U, G, A, O>, ...args: A) => Awaitable<void | Fragment>;
     type Usage<U extends User.Field = never, G extends Channel.Field = never> = string | ((session: Session<U, G>) => Awaitable<string>);
@@ -310,3 +324,3 @@ }
     use<T extends Command, R extends any[]>(callback: (command: this, ...args: R) => T, ...args: R): T;
-    execute(argv: Argv<U, G, A, O>, fallback?: typeof Next.compose): Promise<string | segment>;
+    execute(argv: Argv<U, G, A, O>, fallback?: typeof Next.compose): Promise<Fragment>;
     dispose(): void;
@@ -332,16 +346,18 @@ }
 }
-export interface Context {
-    $commander: Commander;
-    command<D extends string>(def: D, config?: Command.Config): Command<never, never, Argv.ArgumentType<D>>;
-    command<D extends string>(def: D, desc: string, config?: Command.Config): Command<never, never, Argv.ArgumentType<D>>;
+declare module '@satorijs/core' {
+    interface Context {
+        $commander: Commander;
+        command<D extends string>(def: D, config?: Command.Config): Command<never, never, Argv.ArgumentType<D>>;
+        command<D extends string>(def: D, desc: string, config?: Command.Config): Command<never, never, Argv.ArgumentType<D>>;
+    }
+    interface Events {
+        'before-parse'(content: string, session: Session): Argv;
+        'command-added'(command: Command): void;
+        'command-removed'(command: Command): void;
+        'command-error'(argv: Argv, error: any): void;
+        'command/before-execute'(argv: Argv): Awaitable<void | string>;
+        'command/before-attach-channel'(argv: Argv, fields: Set<Channel.Field>): void;
+        'command/before-attach-user'(argv: Argv, fields: Set<User.Field>): void;
+    }
 }
-export interface Events {
-    'before-parse'(content: string, session: Session): Argv;
-    'command-added'(command: Command): void;
-    'command-removed'(command: Command): void;
-    'command-error'(argv: Argv, error: any): void;
-    'command/before-execute'(argv: Argv): Awaitable<void | string>;
-    'command/before-attach-channel'(argv: Argv, fields: Set<Channel.Field>): void;
-    'command/before-attach-user'(argv: Argv, fields: Set<User.Field>): void;
-}
 export namespace Commander {
@@ -365,2 +381,38 @@ interface Config {
 }
+declare module '@satorijs/core' {
+    interface Session<U extends User.Field = never, G extends Channel.Field = never> {
+        argv?: Argv<U, G>;
+        user?: User.Observed<U>;
+        channel?: Channel.Observed<G>;
+        guild?: Channel.Observed<G>;
+        parsed?: Parsed;
+        scope?: string;
+        username?: string;
+        send(content: Fragment): Promise<string[]>;
+        cancelQueued(delay?: number): void;
+        sendQueued(content: Fragment, delay?: number): Promise<string[]>;
+        resolveValue<T>(source: T | ((session: Session) => T)): T;
+        getChannel<K extends Channel.Field = never>(id?: string, fields?: K[]): Promise<Channel>;
+        observeChannel<T extends Channel.Field = never>(fields?: Iterable<T>): Promise<Channel.Observed<T | G>>;
+        getUser<K extends User.Field = never>(id?: string, fields?: K[]): Promise<User>;
+        observeUser<T extends User.Field = never>(fields?: Iterable<T>): Promise<User.Observed<T | U>>;
+        withScope<T>(scope: string, callback: () => T): Promisify<T>;
+        text(path: string | string[], params?: object): string;
+        collect<T extends 'user' | 'channel'>(key: T, argv: Argv, fields?: Set<keyof Tables[T]>): Set<keyof Tables[T]>;
+        inferCommand(argv: Argv): Command;
+        resolve(argv: Argv): Command;
+        execute(content: string, next?: true | Next): Promise<string>;
+        execute(argv: Argv, next?: true | Next): Promise<string>;
+        middleware(middleware: Middleware): () => boolean;
+        prompt(timeout?: number): Promise<string>;
+    }
+    namespace Session {
+        interface Private extends Session {
+            _queuedTasks: Task[];
+            _queuedTimeout: NodeJS.Timeout;
+            _next(): void;
+            _observeChannelLike<T extends Channel.Field = never>(channelId: string, fields: Iterable<T>): Promise<any>;
+        }
+    }
+}
 export interface Parsed {
@@ -372,39 +424,8 @@ content: string;
 export type Computed<T> = T | ((session: Session) => T);
-export namespace Session {
-    interface Payload extends satori.Session.Payload {
-    }
+export interface Task {
+    delay: number;
+    content: Fragment;
+    resolve(ids: string[]): void;
+    reject(reason: any): void;
 }
-export class Session<U extends User.Field = never, G extends Channel.Field = never> extends satori.Session<Context> {
-    argv?: Argv<U, G>;
-    user?: User.Observed<U>;
-    channel?: Channel.Observed<G>;
-    guild?: Channel.Observed<G>;
-    parsed?: Parsed;
-    scope?: string;
-    private _queuedTasks;
-    private _queuedTimeout;
-    constructor(bot: satori.Bot<Context>, payload: Partial<Session.Payload>);
-    get username(): string;
-    send(content: string | satori.segment): Promise<string[]>;
-    cancelQueued(delay?: any): void;
-    private _next;
-    sendQueued(content: string | satori.segment, delay?: number): Promise<string[]>;
-    resolveValue<T>(source: T | ((session: Session) => T)): T;
-    getChannel<K extends Channel.Field = never>(id?: string, fields?: K[]): Promise<any>;
-    /** 在当前会话上绑定一个可观测频道实例 */
-    _observeChannelLike<T extends Channel.Field = never>(channelId: string, fields?: Iterable<T>): Promise<Channel.Observed<any>>;
-    observeChannel<T extends Channel.Field = never>(fields?: Iterable<T>): Promise<Channel.Observed<T | G>>;
-    getUser<K extends User.Field = never>(id?: string, fields?: K[]): Promise<any>;
-    /** 在当前会话上绑定一个可观测用户实例 */
-    observeUser<T extends User.Field = never>(fields?: Iterable<T>): Promise<User.Observed<T | U>>;
-    withScope<T>(scope: string, callback: () => T): Promise<T extends Promise<infer S> ? S : T>;
-    text(path: string | string[], params?: object): string;
-    collect<T extends 'user' | 'channel'>(key: T, argv: Argv, fields?: Set<keyof Tables[T]>): Set<keyof Tables[T]>;
-    private inferCommand;
-    resolve(argv: Argv): Command<never, never, any[], {}>;
-    execute(content: string, next?: true | Next): Promise<string>;
-    execute(argv: Argv, next?: true | Next): Promise<string>;
-    middleware(middleware: Middleware): () => boolean;
-    prompt(timeout?: any): Promise<string>;
-}
 export function getSessionId(session: Session): string;
@@ -421,2 +442,3 @@ export type FieldCollector<T extends keyof Tables, K = keyof Tables[T], A extends any[] = any[], O = {}> = Iterable<K> | ((argv: Argv<never, never, A, O>, fields: Set<keyof Tables[T]>) => void);
 export type Runtime = cordis.Runtime<Context>;
+export type Service = cordis.Service<Context>;
 export const Service: {
@@ -427,72 +449,46 @@ new (ctx: Context, name: string, immediate?: boolean): cordis.Service<Context>;
 export type { Disposable } from 'cordis';
-export interface Events<C extends Context = Context> extends satori.Events<C> {
-    'appellation'(name: string, session: Session): string;
-}
-export interface Context {
-    [Context.events]: Events<this>;
-    [Context.session]: Session;
-    [Context.config]: Context.Config;
-}
-export class Context extends satori.Context {
-    constructor(options?: Context.Config);
-    get app(): cordis.Context.Parameterized<this, this[typeof cordis.Context.config]>;
-    /** @deprecated use `root.config` instead */
-    get options(): this[typeof cordis.Context.config];
-}
-export namespace Context {
-    interface Config extends satori.Context.Config, Config.Basic, Config.Message, Config.Advanced {
+declare module '@satorijs/core' {
+    interface Context {
     }
-    namespace Config {
-        interface Basic {
-            locale?: string;
-            prefix?: Computed<string | string[]>;
-            nickname?: string | string[];
-            autoAssign?: Computed<Awaitable<boolean>>;
-            autoAuthorize?: Computed<Awaitable<number>>;
+    namespace Context {
+        interface Config extends Config.Basic, Config.Message, Config.Advanced {
         }
-        interface Message {
-            delay?: DelayConfig;
+        namespace Config {
+            interface Basic {
+                locale?: string;
+                prefix?: Computed<string | string[]>;
+                nickname?: string | string[];
+                autoAssign?: Computed<Awaitable<boolean>>;
+                autoAuthorize?: Computed<Awaitable<number>>;
+            }
+            interface Message {
+                delay?: DelayConfig;
+            }
+            interface DelayConfig {
+                character?: number;
+                message?: number;
+                cancel?: number;
+                broadcast?: number;
+                prompt?: number;
+            }
+            interface Advanced {
+                maxListeners?: number;
+                prettyErrors?: boolean;
+            }
+            interface Static extends Schema<Config> {
+                Basic: Schema<Basic>;
+                Message: Schema<Message>;
+                Advanced: Schema<Advanced>;
+            }
         }
-        interface DelayConfig {
-            character?: number;
-            message?: number;
-            cancel?: number;
-            broadcast?: number;
-            prompt?: number;
-        }
-        interface Advanced {
-            maxListeners?: number;
-            prettyErrors?: boolean;
-        }
-        interface Static extends Schema<Config> {
-            Basic: Schema<Basic>;
-            Message: Schema<Message>;
-            Advanced: Schema<Advanced>;
-        }
     }
-    const Config: Config.Static;
 }
 export { Context as App };
 export function defineConfig(config: Context.Config): Context.Config;
+declare const kTemplate: unique symbol;
 declare module '@satorijs/core' {
-    interface Bot {
-        getGuildMemberMap(guildId: string): Promise<Dict<string>>;
-        broadcast(channels: (string | [string, string])[], content: string | satori.segment, delay?: number): Promise<string[]>;
+    interface Context {
+        i18n: I18n;
     }
 }
-export type { Message } from '@satorijs/core';
-export { Adapter, h, segment, Logger, Quester } from '@satorijs/core';
-export type Filter = satori.Filter<Context>;
-export const Bot: (abstract new (ctx: Context, config: satori.Bot.Config) => satori.Bot<Context, satori.Bot.Config>) & {
-    reusable: boolean;
-};
-export type Bot = satori.Bot<Context>;
-export namespace Bot {
-    type Status = satori.Bot.Status;
-    type Config = satori.Bot.Config;
-}
-declare const kTemplate: unique symbol;
-export interface Context {
-    i18n: I18n;
-}
 export namespace I18n {
@@ -521,11 +517,22 @@ type Node = string | Store;
 }
-export interface Context {
-    logger(name: string): Logger;
-    waterfall<K extends keyof GetEvents<this>>(name: K, ...args: Parameters<GetEvents<this>[K]>): Promisify<ReturnType<GetEvents<this>[K]>>;
-    waterfall<K extends keyof GetEvents<this>>(thisArg: ThisType<GetEvents<this>[K]>, name: K, ...args: Parameters<GetEvents<this>[K]>): Promisify<ReturnType<GetEvents<this>[K]>>;
-    chain<K extends keyof GetEvents<this>>(name: K, ...args: Parameters<GetEvents<this>[K]>): ReturnType<GetEvents<this>[K]>;
-    chain<K extends keyof GetEvents<this>>(thisArg: ThisType<GetEvents<this>[K]>, name: K, ...args: Parameters<GetEvents<this>[K]>): ReturnType<GetEvents<this>[K]>;
-    before<K extends BeforeEventName>(name: K, listener: BeforeEventMap[K], append?: boolean): () => boolean;
-    setTimeout(callback: (...args: any[]) => void, ms: number, ...args: any[]): () => boolean;
-    setInterval(callback: (...args: any[]) => void, ms: number, ...args: any[]): () => boolean;
+declare module '@satorijs/core' {
+    interface Context {
+        /** @deprecated use `ctx.root` instead */
+        app: Context;
+        /** @deprecated use `root.config` instead */
+        options: Context.Config;
+        logger(name: string): Logger;
+        waterfall<K extends keyof GetEvents<this>>(name: K, ...args: Parameters<GetEvents<this>[K]>): Promisify<ReturnType<GetEvents<this>[K]>>;
+        waterfall<K extends keyof GetEvents<this>>(thisArg: ThisType<GetEvents<this>[K]>, name: K, ...args: Parameters<GetEvents<this>[K]>): Promisify<ReturnType<GetEvents<this>[K]>>;
+        chain<K extends keyof GetEvents<this>>(name: K, ...args: Parameters<GetEvents<this>[K]>): ReturnType<GetEvents<this>[K]>;
+        chain<K extends keyof GetEvents<this>>(thisArg: ThisType<GetEvents<this>[K]>, name: K, ...args: Parameters<GetEvents<this>[K]>): ReturnType<GetEvents<this>[K]>;
+        before<K extends BeforeEventName>(name: K, listener: BeforeEventMap[K], append?: boolean): () => boolean;
+        setTimeout(callback: (...args: any[]) => void, ms: number, ...args: any[]): () => boolean;
+        setInterval(callback: (...args: any[]) => void, ms: number, ...args: any[]): () => boolean;
+    }
+    namespace Context {
+        interface Private extends Context {
+            createTimerDispose(timer: NodeJS.Timeout): () => boolean;
+        }
+    }
 }
@@ -537,17 +544,4 @@ type OmitSubstring<S extends string, T extends string> = S extends `${infer L}${T}${infer R}` ? `${L}${R}` : never;
 };
-export class SelectorService<C extends Context = Context> {
-    private app;
-    static readonly methods: string[];
-    constructor(app: C);
-    protected get caller(): Context;
-    logger(name: string): Logger;
-    waterfall(...args: [any, ...any[]]): Promise<any>;
-    chain(...args: [any, ...any[]]): any;
-    before<K extends BeforeEventName>(name: K, listener: BeforeEventMap[K], append?: boolean): () => boolean;
-    private createTimerDispose;
-    setTimeout(callback: (...args: any[]) => void, ms: number, ...args: any[]): () => boolean;
-    setInterval(callback: (...args: any[]) => void, ms: number, ...args: any[]): () => boolean;
-}
 export * from '@koishijs/utils';
 export * from '@minatojs/core';
 export { version };

package.json

 {
   "name": "@koishijs/core",
   "description": "Core Features for Koishi",
-  "version": "4.9.6",
+  "version": "4.9.7",
   "main": "lib/index.cjs",
@@ -33,7 +33,8 @@ "module": "lib/index.mjs",
   "dependencies": {
-    "@koishijs/utils": "^6.2.3",
-    "@minatojs/core": "^1.3.1",
-    "@satorijs/core": "^1.2.5",
-    "cordis": "^2.5.0"
+    "@koishijs/utils": "^6.2.4",
+    "@minatojs/core": "^1.3.2",
+    "@satorijs/core": "^1.3.1",
+    "cordis": "^2.5.0",
+    "cosmokit": "^1.3.3"
   }
 }

No alert changes

Worsened metrics

Total package byte prevSize

441796

decreased by-0.46%

Dependency count

5

increased by25%

Lines of code

4489

decreased by-0.44%

Dependency changes

• + Addedcosmokit@^1.3.3

• Updated@koishijs/utils@^6.2.4

• Updated@minatojs/core@^1.3.2

• Updated@satorijs/core@^1.3.1