koishi-core - npm Package Compare versions

Comparing version 3.0.0-alpha.0 to 3.0.0-beta.0

dist/app.d.ts

 /// <reference types="node" />
 import { Observed } from 'koishi-utils';
+import { Context } from './context';
+import { BotOptions } from './server';
+import { Channel, User } from './database';
 import { Command } from './command';
-import { Context } from './context';
-import { Group, User, Database } from './database';
-import { BotOptions, Server, Bot } from './server';
 import { Session } from './session';
 import LruCache from 'lru-cache';
 import * as http from 'http';
-import type Router from 'koa-router';
+export interface DelayOptions {
+    character?: number;
+    message?: number;
+    cancel?: number;
+    broadcast?: number;
+    prompt?: number;
+}
 export interface AppOptions extends BotOptions {
@@ -18,7 +24,6 @@ port?: number;
     prettyErrors?: boolean;
-    promptTimeout?: number;
     processMessage?: (message: string) => string;
-    queueDelay?: number | ((message: string, session: Session) => number);
-    broadcastDelay?: number;
-    defaultAuthority?: number | ((session: Session) => number);
+    delay?: DelayOptions;
+    autoAssign?: boolean | ((session: Session) => boolean);
+    autoAuthorize?: number | ((session: Session) => number);
     similarityCoefficient?: number;
@@ -39,14 +44,12 @@ userCacheLength?: number;
     options: AppOptions;
-    bots: Record<string, Bot>;
-    servers: Record<string, Server>;
     status: AppStatus;
-    router?: Router;
-    _httpServer?: http.Server;
-    _database: Database;
+    bots: import("./server").Bot[] & Record<string, import("./server").Bot>;
     _commands: Command[];
-    _sessions: Record<string, Session>;
     _commandMap: Record<string, Command>;
+    _shortcuts: Command.Shortcut[];
     _hooks: Record<keyof any, [Context, (...args: any[]) => any][]>;
     _userCache: Record<string, LruCache<string, Observed<Partial<User>, Promise<void>>>>;
-    _groupCache: LruCache<string, Observed<Partial<Group>, Promise<void>>>;
+    _groupCache: LruCache<string, Observed<Partial<Channel>, Promise<void>>>;
+    _httpServer?: http.Server;
+    _sessions: Record<string, Session>;
     private _nameRE;
@@ -63,4 +66,4 @@ private _prefixRE;
     private _preprocess;
-    private _receive;
-    private _parse;
+    private _onMessage;
+    private _onShortcut;
 }

dist/command.d.ts

 /// <reference types="node" />
+import { Argv, Domain } from './parser';
 import { Context, NextFunction } from './context';
-import { User, Group, Tables, TableType } from './database';
-import { Session } from './session';
+import { User, Channel } from './database';
+import { FieldCollector, Session } from './session';
 import { inspect } from 'util';
-export interface CommandArgument {
-    required: boolean;
-    variadic: boolean;
-    greedy: boolean;
-    name: string;
-}
-export declare function parseArguments(source: string): CommandArgument[];
-declare const supportedType: readonly ["string", "number", "boolean"];
-export declare type OptionType = typeof supportedType[number];
-export interface OptionConfig<T = any> {
-    value?: T;
-    fallback?: T;
-}
-declare type StringOptionConfig = OptionConfig & ({
-    fallback: string;
-} | {
-    type: 'string';
-});
-declare type NumberOptionConfig = OptionConfig & ({
-    fallback: number;
-} | {
-    type: 'number';
-});
-declare type BooleanOptionConfig = OptionConfig & ({
-    fallback: boolean;
-} | {
-    type: 'boolean';
-});
-export interface CommandOption extends OptionConfig {
-    name: string;
-    description: string;
-    greedy: boolean;
-    type?: OptionType;
-    values?: Record<string, any>;
-}
-export interface ParsedLine<O extends {} = {}> {
-    source?: string;
-    rest: string;
-    args: string[];
-    options: O;
-}
-export interface ParsedArgv<U extends User.Field = never, G extends Group.Field = never, O extends {} = {}> extends Partial<ParsedLine<O>> {
-    command: Command<U, G, O>;
-    session: Session<U, G, O>;
-    next?: NextFunction;
-}
-export interface ExecuteArgv extends Partial<ParsedLine> {
-    command: string | Command;
-    next?: NextFunction;
-}
-export interface CommandConfig<U extends User.Field = never, G extends Group.Field = never> {
-    /** description */
-    description?: string;
-}
-declare type Extend<O extends {}, K extends string, T> = {
+export declare type UserType<T, U extends User.Field = User.Field> = T | ((user: Pick<User, U>) => T);
+export declare type Extend<O extends {}, K extends string, T> = {
     [P in K | keyof O]?: (P extends keyof O ? O[P] : unknown) & (P extends K ? T : unknown);
 };
-export declare type FieldCollector<T extends TableType, K = keyof Tables[T], O extends {} = {}> = Iterable<K> | ((argv: ParsedArgv<never, never, O>, fields: Set<keyof Tables[T]>) => void);
-export declare type CommandAction<U extends User.Field = never, G extends Group.Field = never, O extends {} = {}> = (this: Command<U, G, O>, argv: ParsedArgv<U, G, O>, ...args: string[]) => void | string | Promise<void | string>;
-export declare class Command<U extends User.Field = never, G extends Group.Field = never, O extends {} = {}> {
-    name: string;
-    declaration: string;
+export declare namespace Command {
+    interface Config {
+        /** hide all options by default */
+        hideOptions?: boolean;
+        /** hide command */
+        hidden?: boolean;
+        /** min authority */
+        authority?: number;
+        /** disallow unknown options */
+        checkUnknown?: boolean;
+        /** check argument count */
+        checkArgCount?: boolean;
+        /** show command warnings */
+        showWarning?: boolean;
+        /** usage identifier */
+        usageName?: string;
+        /** max usage per day */
+        maxUsage?: UserType<number>;
+        /** min interval */
+        minInterval?: UserType<number>;
+    }
+    interface Shortcut {
+        name?: string | RegExp;
+        command?: Command;
+        authority?: number;
+        prefix?: boolean;
+        fuzzy?: boolean;
+        args?: string[];
+        greedy?: boolean;
+        options?: Record<string, any>;
+    }
+    type Action<U extends User.Field = never, G extends Channel.Field = never, A extends any[] = any[], O extends {} = {}> = (this: Command<U, G, A, O>, argv: Argv<U, G, A, O>, ...args: A) => void | string | Promise<void | string>;
+    type Usage<U extends User.Field, G extends Channel.Field> = string | ((this: Command<U, G>, session: Session<U, G>) => string | Promise<string>);
+}
+export declare class Command<U extends User.Field = never, G extends Channel.Field = never, A extends any[] = any[], O extends {} = {}> extends Domain.CommandBase {
     context: Context;
-    config: CommandConfig<U, G>;
+    config: Command.Config;
     children: Command[];
     parent: Command;
     _aliases: string[];
-    _arguments: CommandArgument[];
-    _options: Record<string, CommandOption>;
-    private _optionNameMap;
-    private _optionSymbolMap;
+    _examples: string[];
+    _usage?: Command.Usage<U, G>;
     private _userFields;
-    private _groupFields;
-    _action?: CommandAction<U, G, O>;
-    static defaultConfig: CommandConfig;
-    static defaultOptionConfig: OptionConfig;
+    private _channelFields;
+    _actions: Command.Action<U, G, A, O>[];
+    _checkers: Command.Action<U, G, A, O>[];
+    static defaultConfig: Command.Config;
+    static defaultOptionConfig: Domain.OptionConfig;
     private static _userFields;
-    private static _groupFields;
+    private static _channelFields;
     static userFields(fields: FieldCollector<'user'>): typeof Command;
-    static groupFields(fields: FieldCollector<'group'>): typeof Command;
-    static collect<T extends TableType>(argv: ParsedArgv, key: T, fields?: Set<keyof Tables[T]>): Set<keyof Tables[T]>;
-    constructor(name: string, declaration: string, context: Context, config?: CommandConfig);
+    static channelFields(fields: FieldCollector<'channel'>): typeof Command;
+    constructor(name: string, declaration: string, context: Context, config?: Command.Config);
     get app(): import("./app").App;
     private _registerAlias;
     [inspect.custom](): string;
-    userFields<T extends User.Field = never>(fields: FieldCollector<'user', T, O>): Command<U | T, G, O>;
-    groupFields<T extends Group.Field = never>(fields: FieldCollector<'group', T, O>): Command<U, G | T, O>;
+    userFields<T extends User.Field = never>(fields: FieldCollector<'user', T, A, O>): Command<U | T, G, A, O>;
+    channelFields<T extends Channel.Field = never>(fields: FieldCollector<'channel', T, A, O>): Command<U, G | T, A, O>;
     alias(...names: string[]): this;
-    subcommand(rawName: string, config?: CommandConfig): Command;
-    subcommand(rawName: string, description: string, config?: CommandConfig): Command;
-    private _registerOption;
-    private _assignOption;
-    option<K extends string>(name: K, desc: string, config: StringOptionConfig): Command<U, G, Extend<O, K, string>>;
-    option<K extends string>(name: K, desc: string, config: NumberOptionConfig): Command<U, G, Extend<O, K, number>>;
-    option<K extends string>(name: K, desc: string, config: BooleanOptionConfig): Command<U, G, Extend<O, K, boolean>>;
-    option<K extends string>(name: K, desc: string, config?: OptionConfig): Command<U, G, Extend<O, K, any>>;
-    removeOption<K extends string & keyof O>(name: K): boolean;
-    action(callback: CommandAction<U, G, O>): this;
-    private parseArg;
-    private parseRest;
-    private parseValue;
-    parse(message: string, terminator?: string): ParsedLine;
-    private stringifyArg;
-    stringify(args: readonly string[], options: any): string;
-    execute(argv: ParsedArgv<U, G, O>): any;
+    shortcut(name: string | RegExp, config?: Command.Shortcut): this;
+    subcommand<D extends string>(def: D, config?: Command.Config): Command<never, never, Domain.ArgumentType<D>>;
+    subcommand<D extends string>(def: D, decl: string, config?: Command.Config): Command<never, never, Domain.ArgumentType<D>>;
+    usage(text: Command.Usage<U, G>): this;
+    example(example: string): this;
+    option<K extends string, D extends string, T extends Domain.Type>(name: K, desc: D, config?: Domain.OptionConfig<T>, action?: Command.Action<U, G, A, Extend<O, K, Domain.OptionType<D, T>>>): Command<U, G, A, Extend<O, K, Domain.OptionType<D, T>>>;
+    check(callback: Command.Action<U, G, A, O>, prepend?: boolean): this;
+    getConfig<K extends keyof Command.Config>(key: K, session: Session): Exclude<Command.Config[K], (user: User) => any>;
+    action(callback: Command.Action<U, G, A, O>, append?: boolean): this;
+    execute(argv0: Argv<U, G, A, O>, next?: NextFunction): Promise<string>;
     dispose(): void;
 }
-export {};

dist/context.d.ts

 import { Logger } from 'koishi-utils';
-import { Command, CommandConfig, ParsedArgv, ExecuteArgv } from './command';
-import { EventType, Session } from './session';
-import { User, Group, PlatformKind } from './database';
+import { Command } from './command';
+import { Session, SessionType } from './session';
+import { User, Channel, Database } from './database';
+import { Argv, Domain } from './parser';
+import { Server } from './server';
 import { App } from './app';
+import type Router from 'koa-router';
 export declare type NextFunction = (next?: NextFunction) => Promise<void>;
 export declare type Middleware = (session: Session, next: NextFunction) => any;
-export declare type PluginFunction<T, U = any> = (ctx: T, options: U) => void;
-export declare type PluginObject<T, U = any> = {
+export declare type PluginFunction<T = any> = (ctx: Context, options: T) => void;
+export declare type PluginObject<T = any> = {
     name?: string;
-    apply: PluginFunction<T, U>;
+    apply: PluginFunction<T>;
 };
-export declare type Plugin<T, U = any> = PluginFunction<T, U> | PluginObject<T, U>;
+export declare type Plugin<T = any> = PluginFunction<T> | PluginObject<T>;
+export declare type Promisify<T> = T extends Promise<any> ? T : Promise<T>;
+export declare type Depromisify<T> = T extends Promise<infer U> ? U : T;
 export declare type Disposable = () => void;
-interface ScopeSet extends Array<string> {
-    positive?: boolean;
-}
-interface Scope {
-    groups: ScopeSet;
-    users: ScopeSet;
-    private: boolean;
-}
+declare type PluginConfig<T extends Plugin> = T extends PluginFunction<infer U> ? U : T extends PluginObject<infer U> ? U : never;
+declare type Filter = (session: Session) => boolean;
 export declare class Context {
-    scope: Scope;
+    filter: Filter;
     app?: App;
-    static readonly MIDDLEWARE_EVENT: unique symbol;
+    static readonly middleware: unique symbol;
+    protected _router: Router;
+    protected _database: Database;
+    protected _servers: Record<string, Server>;
     private _disposables;
-    constructor(scope: Scope, app?: App);
-    get database(): import("./database").Database;
-    set database(database: import("./database").Database);
+    constructor(filter: Filter, app?: App);
+    get router(): Router<any, {}>;
+    get servers(): Record<string, Server<import("./server").Bot>>;
+    get database(): Database;
+    set database(database: Database);
     logger(name: string): Logger;
-    group(...ids: string[]): Context;
-    user(...ids: string[]): Context;
-    private(...ids: string[]): Context;
-    match(session: Session): boolean;
-    plugin<T extends PluginFunction<this>>(plugin: T, options?: T extends PluginFunction<this, infer U> ? U : never): this;
-    plugin<T extends PluginObject<this>>(plugin: T, options?: T extends PluginObject<this, infer U> ? U : never): this;
-    parallel<K extends keyof EventMap>(name: K, ...args: Parameters<EventMap[K]>): Promise<void>;
-    parallel<K extends keyof EventMap>(session: Session, name: K, ...args: Parameters<EventMap[K]>): Promise<void>;
-    emit<K extends keyof EventMap>(name: K, ...args: Parameters<EventMap[K]>): void;
-    emit<K extends keyof EventMap>(session: Session, name: K, ...args: Parameters<EventMap[K]>): void;
-    serial<K extends keyof EventMap>(name: K, ...args: Parameters<EventMap[K]>): Promise<ReturnType<EventMap[K]>>;
-    serial<K extends keyof EventMap>(session: Session, name: K, ...args: Parameters<EventMap[K]>): Promise<ReturnType<EventMap[K]>>;
-    bail<K extends keyof EventMap>(name: K, ...args: Parameters<EventMap[K]>): ReturnType<EventMap[K]>;
-    bail<K extends keyof EventMap>(session: Session, name: K, ...args: Parameters<EventMap[K]>): ReturnType<EventMap[K]>;
+    select<K extends keyof Session>(key: K, ...values: Session[K][]): Context;
+    unselect<K extends keyof Session>(key: K, ...values: Session[K][]): Context;
+    union(arg: Filter | Context): Context;
+    intersect(arg: Filter | Context): Context;
+    match(session?: Session): boolean;
+    plugin<T extends Plugin>(plugin: T, options?: PluginConfig<T>): this;
+    parallel<K extends EventName>(name: K, ...args: Parameters<EventMap[K]>): Promise<Depromisify<ReturnType<EventMap[K]>>[]>;
+    parallel<K extends EventName>(session: Session, name: K, ...args: Parameters<EventMap[K]>): Promise<Depromisify<ReturnType<EventMap[K]>>[]>;
+    emit<K extends EventName>(name: K, ...args: Parameters<EventMap[K]>): void;
+    emit<K extends EventName>(session: Session, name: K, ...args: Parameters<EventMap[K]>): void;
+    chain<K extends EventName>(name: K, ...args: Parameters<EventMap[K]>): ReturnType<EventMap[K]>;
+    chain<K extends EventName>(session: Session, name: K, ...args: Parameters<EventMap[K]>): ReturnType<EventMap[K]>;
+    serial<K extends EventName>(name: K, ...args: Parameters<EventMap[K]>): Promisify<ReturnType<EventMap[K]>>;
+    serial<K extends EventName>(session: Session, name: K, ...args: Parameters<EventMap[K]>): Promisify<ReturnType<EventMap[K]>>;
+    bail<K extends EventName>(name: K, ...args: Parameters<EventMap[K]>): ReturnType<EventMap[K]>;
+    bail<K extends EventName>(session: Session, name: K, ...args: Parameters<EventMap[K]>): ReturnType<EventMap[K]>;
     private getHooks;
-    on<K extends keyof EventMap>(name: K, listener: EventMap[K]): () => boolean;
-    addListener<K extends keyof EventMap>(name: K, listener: EventMap[K]): () => boolean;
-    prependListener<K extends keyof EventMap>(name: K, listener: EventMap[K]): () => boolean;
-    once<K extends keyof EventMap>(name: K, listener: EventMap[K]): () => boolean;
-    off<K extends keyof EventMap>(name: K, listener: EventMap[K]): boolean;
-    removeListener<K extends keyof EventMap>(name: K, listener: EventMap[K]): boolean;
-    middleware(middleware: Middleware): () => boolean;
-    addMiddleware(middleware: Middleware): () => boolean;
-    prependMiddleware(middleware: Middleware): () => boolean;
+    on<K extends EventName>(name: K, listener: EventMap[K]): () => boolean;
+    addListener<K extends EventName>(name: K, listener: EventMap[K]): () => boolean;
+    before<K extends BeforeEventName>(name: K, listener: BeforeEventMap[K]): () => boolean;
+    prependListener<K extends EventName>(name: K, listener: EventMap[K]): () => boolean;
+    once<K extends EventName>(name: K, listener: EventMap[K]): () => boolean;
+    off<K extends EventName>(name: K, listener: EventMap[K]): boolean;
+    removeListener<K extends EventName>(name: K, listener: EventMap[K]): boolean;
+    middleware(middleware: Middleware, prepend?: boolean): () => boolean;
     removeMiddleware(middleware: Middleware): boolean;
-    command(rawName: string, config?: CommandConfig): Command;
-    command(rawName: string, description: string, config?: CommandConfig): Command;
-    broadcast(message: string, forced?: boolean): Promise<string[]>;
-    broadcast(groups: readonly string[], message: string, forced?: boolean): Promise<string[]>;
+    command<D extends string>(def: D, config?: Command.Config): Command<never, never, Domain.ArgumentType<D>>;
+    command<D extends string>(def: D, desc: string, config?: Command.Config): Command<never, never, Domain.ArgumentType<D>>;
+    broadcast(content: string, forced?: boolean): Promise<string[]>;
+    broadcast(channels: readonly string[], content: string, forced?: boolean): Promise<string[]>;
     dispose(): void;
 }
-export declare type RawSession<E extends EventType = EventType> = Session<never, never, never, PlatformKind, E>;
-export interface EventMap {
-    [Context.MIDDLEWARE_EVENT]: Middleware;
-    'message'(session: RawSession<'message'>): void;
-    'message/friend'(session: RawSession<'message'>): void;
-    'message/group'(session: RawSession<'message'>): void;
-    'message-edited'(session: RawSession<'message'>): void;
-    'message-edited/friend'(session: RawSession<'message'>): void;
-    'message-edited/group'(session: RawSession<'message'>): void;
-    'message-deleted'(session: RawSession<'message'>): void;
-    'message-deleted/friend'(session: RawSession<'message'>): void;
-    'message-deleted/group'(session: RawSession<'message'>): void;
-    'friend-added'(session: Session): void;
-    'friend-deleted'(session: Session): void;
-    'group'(session: Session): void;
-    'group-added'(session: Session): void;
-    'group-deleted'(session: Session): void;
-    'group-member'(session: Session): void;
-    'group-member-added'(session: Session): void;
-    'group-member-deleted'(session: Session): void;
-    'group-upload'(session: Session): void;
-    'group-admin'(session: Session): void;
-    'group-admin/set'(session: Session): void;
-    'group-admin/unset'(session: Session): void;
-    'group-ban'(session: Session): void;
-    'group-ban/ban'(session: Session): void;
-    'group-ban/lift-ban'(session: Session): void;
-    'notify'(session: Session): void;
-    'notify/poke'(session: Session): void;
-    'notify/lucky_king'(session: Session): void;
-    'notify/honor'(session: Session): void;
-    'request/friend'(session: Session): void;
-    'request/group/add'(session: Session): void;
-    'request/group/invite'(session: Session): void;
-    'lifecycle/enable'(session: RawSession<'lifecycle'>): void;
-    'lifecycle/disable'(session: RawSession<'lifecycle'>): void;
-    'lifecycle/connect'(session: RawSession<'lifecycle'>): void;
-    'lifecycle/heartbeat'(session: RawSession<'lifecycle'>): void;
-    'parse'(message: string, session: Session, builtin: boolean, terminator: string): void | ExecuteArgv;
+declare type FlattenEvents<T> = {
+    [K in keyof T & string]: K | `${K}/${FlattenEvents<T[K]>}`;
+}[keyof T & string];
+declare type SessionEventMap = Record<FlattenEvents<SessionType>, (session: Session) => void>;
+declare type EventName = keyof EventMap;
+declare type OmitSubstring<S extends string, T extends string> = S extends `${infer L}${T}${infer R}` ? `${L}${R}` : never;
+declare type BeforeEventName = OmitSubstring<EventName & string, 'before-'>;
+declare type BeforeEventMap = {
+    [E in EventName & string as OmitSubstring<E, 'before-'>]: EventMap[E];
+};
+export interface EventMap extends SessionEventMap {
+    [Context.middleware]: Middleware;
+    'appellation'(name: string, session: Session): string;
+    'tokenize'(content: string, session: Session): Argv;
+    'parse'(argv: Argv, session: Session): string;
     'before-attach-user'(session: Session, fields: Set<User.Field>): void;
-    'before-attach-group'(session: Session, fields: Set<Group.Field>): void;
+    'before-attach-channel'(session: Session, fields: Set<Channel.Field>): void;
     'attach-user'(session: Session): void | boolean | Promise<void | boolean>;
-    'attach-group'(session: Session): void | boolean | Promise<void | boolean>;
-    'attach'(session: Session): void | Promise<void>;
-    'send'(session: Session): void | Promise<void>;
+    'attach-channel'(session: Session): void | boolean | Promise<void | boolean>;
     'before-send'(session: Session): void | boolean;
-    'before-command'(argv: ParsedArgv): void | string | Promise<void | string>;
-    'command'(argv: ParsedArgv): void | Promise<void>;
+    'before-command'(argv: Argv): void | string | Promise<void | string>;
+    'command'(argv: Argv): void | Promise<void>;
     'middleware'(session: Session): void;
-    'new-command'(cmd: Command): void;
-    'remove-command'(cmd: Command): void;
     'before-connect'(): void | Promise<void>;
@@ -120,3 +97,2 @@ 'connect'(): void;
 }
-export declare type Events = keyof EventMap;
 export {};

dist/database.d.ts

@@ -5,5 +5,5 @@ import * as utils from 'koishi-utils';
     user: User;
-    group: Group;
+    channel: Channel;
 }
-export interface User extends Record<PlatformKind, string> {
+export interface User extends Record<PlatformType, string> {
     id: number;
@@ -23,5 +23,5 @@ flag: number;
     export type Observed<K extends Field = Field> = utils.Observed<Pick<User, K>, Promise<void>>;
-    type Getter = (type: PlatformKind, id: string, authority: number) => Partial<User>;
+    type Getter = (type: PlatformType, id: string) => Partial<User>;
     export function extend(getter: Getter): void;
-    export function create(type: PlatformKind, id: string, authority: number): User;
+    export function create(type: PlatformType, id: string): User;
     export {};
@@ -31,10 +31,9 @@ }
 }
-export declare type PlatformKind = keyof Platforms;
-export interface Group {
+export declare type PlatformType = keyof Platforms;
+export interface Channel {
     id: string;
-    type: PlatformKind;
     flag: number;
     assignee: string;
 }
-export declare namespace Group {
+export declare namespace Channel {
     export enum Flag {
@@ -44,17 +43,26 @@ ignore = 1,
     }
-    export type Field = keyof Group;
+    export type Field = keyof Channel;
     export const fields: Field[];
-    export type Observed<K extends Field = Field> = utils.Observed<Pick<Group, K>, Promise<void>>;
-    type Getter = (type: PlatformKind, id: string, assignee: string) => Partial<Group>;
+    export type Observed<K extends Field = Field> = utils.Observed<Pick<Channel, K>, Promise<void>>;
+    type Getter = (type: PlatformType, id: string) => Partial<Channel>;
     export function extend(getter: Getter): void;
-    export function create(type: PlatformKind, id: string, assignee: string): Group;
+    export function create(type: PlatformType, id: string): Channel;
     export {};
 }
+declare type MaybeArray<T> = T | readonly T[];
+declare type At<O, T extends keyof O, F> = [T] extends [never] ? F : O[T];
 export interface Database {
-    getUser<K extends User.Field>(type: PlatformKind, id: string, fields?: readonly K[]): Promise<Pick<User, K>>;
-    getUsers<K extends User.Field>(type: PlatformKind, ids?: readonly string[], fields?: readonly K[]): Promise<Pick<User, K>[]>;
-    setUser(type: PlatformKind, id: string, data: Partial<User>): Promise<void>;
-    getGroup<K extends Group.Field>(type: PlatformKind, id: string, fields?: readonly K[]): Promise<Pick<Group, K | 'id' | 'type'>>;
-    getAllGroups<K extends Group.Field>(fields?: readonly K[], assignees?: readonly string[]): Promise<Pick<Group, K>[]>;
-    setGroup(type: PlatformKind, id: string, data: Partial<Group>): Promise<void>;
+    getUser<K extends User.Field, T extends User.Field>(type: T, id: User[T], fields?: readonly K[]): Promise<Pick<User, K | T>>;
+    getUser<K extends User.Field, T extends User.Field>(type: T, ids: readonly User[T][], fields?: readonly K[]): Promise<Pick<User, K | T>[]>;
+    getUser<K extends User.Field>(type: string, id: MaybeArray<string>, fields?: readonly K[]): Promise<any>;
+    setUser<T extends User.Field>(type: T, id: At<User, T, string>, data: Partial<User>): Promise<void>;
+    createUser<T extends User.Field>(type: T, id: At<User, T, string>, data: Partial<User>): Promise<void>;
+    removeUser<T extends User.Field>(type: T, id: At<User, T, string>): Promise<void>;
+    getChannel<K extends Channel.Field>(type: PlatformType, id: string, fields?: readonly K[]): Promise<Pick<Channel, K | 'id'>>;
+    getChannel<K extends Channel.Field>(type: PlatformType, ids: readonly string[], fields?: readonly K[]): Promise<Pick<Channel, K | 'id'>[]>;
+    getChannel<K extends Channel.Field>(type: PlatformType, id: MaybeArray<string>, fields?: readonly K[]): Promise<any>;
+    getChannelList<K extends Channel.Field>(fields?: readonly K[], type?: PlatformType, assignees?: readonly string[]): Promise<Pick<Channel, K>[]>;
+    setChannel(type: PlatformType, id: string, data: Partial<Channel>): Promise<void>;
+    createChannel(type: PlatformType, id: string, data: Partial<Channel>): Promise<void>;
+    removeChannel(type: PlatformType, id: string): Promise<void>;
 }
@@ -61,0 +69,0 @@ declare type DatabaseExtensionMethods<I> = {

dist/index.d.ts

@@ -0,1 +1,2 @@
+export * from 'koishi-utils';
 export * from './app';
@@ -5,2 +6,3 @@ export * from './command';
 export * from './database';
+export * from './parser';
 export * from './session';
@@ -10,4 +12,2 @@ export * from './server';
 export * from './plugins/message';
-export * from './plugins/shortcut';
-export * from './plugins/suggest';
 export * from './plugins/validate';

dist/plugins/help.d.ts

@@ -1,24 +0,5 @@
-import { User, Group } from '../database';
 import { Command } from '../command';
 import { Session } from '../session';
 import { App } from '../app';
-export declare type CommandUsage<U extends User.Field, G extends Group.Field> = string | ((this: Command<U, G>, session: Session<U, G>) => string | Promise<string>);
-declare module '../command' {
-    interface Command<U, G> {
-        _usage?: CommandUsage<U, G>;
-        _examples: string[];
-        usage(text: CommandUsage<U, G>): this;
-        example(example: string): this;
-    }
-    interface CommandConfig {
-        /** hide all options by default */
-        hideOptions?: boolean;
-        hidden?: boolean;
-    }
-    interface OptionConfig {
-        /** hide the option by default */
-        hidden?: boolean;
-    }
-}
 export default function apply(app: App): void;
-export declare function getCommands(session: Session<'authority'>, commands: Command[], showHidden?: boolean): Command<never, never, {}>[];
+export declare function getCommands(session: Session<'authority'>, commands: Command[], showHidden?: boolean): Command<never, never, any[], {}>[];

dist/plugins/message.d.ts

@@ -7,2 +7,3 @@ export declare namespace Message {
     let INVALID_OPTION: string;
+    let INVALID_ARGUMENT: string;
     let UNKNOWN_OPTIONS: string;
@@ -9,0 +10,0 @@ let CHECK_SYNTAX: string;

dist/plugins/validate.d.ts

@@ -1,36 +0,4 @@
-import { Session } from '../session';
 import { User } from '../database';
 import { Command } from '../command';
 import { App } from '../app';
-export declare type UserType<T, U extends User.Field = User.Field> = T | ((user: Pick<User, U>) => T);
-declare module '../command' {
-    interface Command<U, G, O> {
-        _checkers: ((session: Session<U, G, O>) => string | boolean)[];
-        before(checker: (session: Session<U, G, O>) => string | boolean): this;
-        getConfig<K extends keyof CommandConfig>(key: K, session: Session): Exclude<CommandConfig[K], (user: User) => any>;
-    }
-    interface OptionConfig<T> {
-        authority?: number;
-        notUsage?: boolean;
-    }
-    interface CommandConfig<U, G> {
-        /** min authority */
-        authority?: number;
-        /** disallow unknown options */
-        checkUnknown?: boolean;
-        /** check argument count */
-        checkArgCount?: boolean;
-        /** show command warnings */
-        showWarning?: boolean;
-        /** usage identifier */
-        usageName?: string;
-        /** max usage per day */
-        maxUsage?: UserType<number>;
-        /** min interval */
-        minInterval?: UserType<number>;
-    }
-    interface OptionConfig {
-        validate?: RegExp | ((value: any) => void | string | boolean);
-    }
-}
 export declare function getUsageName(command: Command): string;
@@ -37,0 +5,0 @@ export declare type ValidationField = 'authority' | 'usage' | 'timers';

dist/server.d.ts

@@ -1,3 +0,4 @@
-import { Session, MessageInfo, EventTypeMap, GroupInfo, GroupMemberInfo, UserInfo } from './session';
+import { Session, MessageInfo, GroupInfo, GroupMemberInfo, UserInfo, MessageSubtype } from './session';
 import { App } from './app';
+import { PlatformType } from './database';
 export interface BotOptions {
@@ -7,2 +8,3 @@ type?: string;
 }
+export declare function createBots<T extends Bot>(key: 'selfId' | 'sid'): T[] & Record<string, T>;
 declare type BotStatic<T extends Bot = Bot> = new (app: App, options: BotOptions) => T;
@@ -13,3 +15,3 @@ export declare abstract class Server<T extends Bot = Bot> {
     static types: Record<string, new (app: App) => Server>;
-    bots: T[];
+    bots: T[] & Record<string, T>;
     abstract listen(): Promise<void>;
@@ -34,9 +36,10 @@ abstract close(): void;
 export interface Bot extends BotOptions {
-    [Bot.$send](session: Session, message: string): Promise<void>;
+    [Bot.send](session: Session, message: string): Promise<void>;
     ready?: boolean;
     version?: string;
+    platform?: PlatformType;
     getSelfId(): Promise<string>;
     getStatusCode(): Promise<BotStatusCode>;
-    sendMessage(channelId: string, message: string): Promise<string>;
-    sendPrivateMessage(userId: string, message: string): Promise<string>;
+    sendMessage(channelId: string, content: string): Promise<string>;
+    sendPrivateMessage(userId: string, content: string): Promise<string>;
     getMessage(channelId: string, messageId: string): Promise<MessageInfo>;
@@ -52,10 +55,13 @@ deleteMessage(channelId: string, messageId: string): Promise<void>;
     app: App;
-    static readonly $send: unique symbol;
+    static readonly send: unique symbol;
+    parseUser(source: string): string;
+    parseChannel(source: string): string;
     constructor(app: App, options: BotOptions);
-    createSession(subType: EventTypeMap['message'], ctxType: 'group' | 'user', ctxId: string, message: string): Session<never, never, {}, never, "message" | "message-edited" | "message-deleted" | "group-added" | "group-deleted" | "lifecycle" | "send">;
+    get sid(): string;
+    createSession(subtype: MessageSubtype, ctxType: 'group' | 'user', ctxId: string, content: string): Session<never, never, never>;
     getGroupMemberMap(groupId: string): Promise<{
         [k: string]: string;
     }>;
-    broadcast(channels: string[], message: string, delay?: number): Promise<string[]>;
+    broadcast(channels: string[], content: string, delay?: number): Promise<string[]>;
 }
 export {};

dist/session.d.ts

@@ -1,38 +0,63 @@
-import { User, Group, Platforms, PlatformKind } from './database';
-import { ExecuteArgv, ParsedArgv } from './command';
-import { NextFunction } from './context';
+import { User, Channel, Platforms, PlatformType, TableType, Tables } from './database';
+import { Command } from './command';
+import { Argv } from './parser';
+import { Middleware, NextFunction } from './context';
 import { App } from './app';
 import { Bot } from './server';
-export declare type EventType = keyof EventTypeMap;
-export declare type MessageType = 'private' | 'group';
-export interface EventTypeMap {
-    'message': MessageType;
-    'message-edited': MessageType;
-    'message-deleted': MessageType;
-    'group-added': null;
-    'group-deleted': null;
-    'lifecycle': 'heartbeat' | 'enable' | 'disable' | 'connect';
-    'send': MessageType;
+declare type UnionToIntersection<U> = (U extends any ? (key: U) => void : never) extends (key: infer I) => void ? I : never;
+declare type Flatten<T> = UnionToIntersection<T[keyof T]>;
+declare type Genres = 'friend' | 'channel' | 'group' | 'group-member' | 'group-role' | 'group-file' | 'group-emoji';
+declare type Actions = 'added' | 'deleted' | 'updated';
+declare type MessageActions = 'message' | 'message-deleted' | 'message-updated' | 'send';
+export interface SessionType extends Record<`${Genres}-${Actions}`, {}>, Record<MessageActions, MessageType> {
+    'friend-request': {};
+    'group-request': {};
+    'group-member-request': {};
+    'group-added': GroupMemberAddedType;
+    'group-member-added': GroupMemberAddedType;
+    'group-deleted': GroupMemberDeletedType;
+    'group-member-deleted': GroupMemberDeletedType;
+    'group-member': {
+        'role': {};
+        'ban': {};
+    };
+    'notice': {
+        'poke': {};
+        'lucky-king': {};
+        'honor': {
+            'talkative': {};
+            'performer': {};
+            'emotion': {};
+        };
+    };
 }
-/** CQHTTP Meta Information */
-export interface Meta<E extends EventType = EventType> {
-    kind?: PlatformKind;
-    eventType?: E;
-    subType?: EventTypeMap[E];
-    channelId?: string;
+interface GroupMemberAddedType {
+    'approve': {};
+    'invite': {};
+}
+interface GroupMemberDeletedType {
+    'leave': {};
+    'kick': {};
+}
+interface MessageType {
+    'private': {};
+    'group': {};
+}
+export interface Meta extends MessageBase {
+    type?: keyof SessionType;
+    subtype?: keyof Flatten<SessionType>;
+    subsubtype?: keyof Flatten<Flatten<SessionType>>;
+    platform?: PlatformType;
     selfId?: string;
-    userId?: string;
-    groupId?: string;
-    time?: number;
+    ancestors?: string[];
     messageId?: string;
-    message?: string;
+    content?: string;
     rawMessage?: string;
     font?: number;
-    sender?: SenderInfo;
+    author?: AuthorInfo;
     anonymous?: AnonymousInfo;
-    operatorId?: number;
-    targetId?: number;
+    operatorId?: string;
+    targetId?: string;
     duration?: number;
     file?: FileInfo;
-    honorType?: 'talkative' | 'performer' | 'emotion';
     comment?: string;
@@ -43,9 +68,9 @@ flag?: string;
 }
-export interface Session<U, G, O, K, E extends EventType = EventType> extends Meta<E> {
+export interface Session<U, G, K> extends Meta {
 }
-export declare class Session<U extends User.Field = never, G extends Group.Field = never, O extends {} = {}, K extends PlatformKind = never> {
+export declare class Session<U extends User.Field = never, G extends Channel.Field = never, K extends PlatformType = never> {
     $user?: User.Observed<U>;
-    $group?: Group.Observed<G>;
+    $channel?: Channel.Observed<G>;
     $app?: App;
-    $argv?: ParsedArgv<U, G, O>;
+    $argv?: Argv<U, G>;
     $appel?: boolean;
@@ -55,3 +80,3 @@ $prefix?: string;
     $reply?: MessageInfo;
-    $uuid: string;
+    $uuid?: string;
     private _delay?;
@@ -66,16 +91,35 @@ private _queued;
     get $username(): string;
-    $send(message: string): any;
-    $cancelQueued(delay?: number): void;
-    $sendQueued(message: string | void, delay?: number): Promise<void>;
-    $getGroup<K extends Group.Field = never>(id?: string, fields?: readonly K[], assignee?: string): Promise<Pick<Group, "id" | "type" | K>>;
-    /** 在元数据上绑定一个可观测群实例 */
-    $observeGroup<T extends Group.Field = never>(fields?: Iterable<T>): Promise<Group.Observed<T | G>>;
-    $getUser<K extends User.Field = never>(id?: string, fields?: readonly K[], authority?: number): Promise<Pick<User, K>>;
-    /** 在元数据上绑定一个可观测用户实例 */
-    $observeUser<T extends User.Field = never>(fields?: Iterable<T>): Promise<User.Observed<T | U>>;
-    $resolve(argv: ExecuteArgv): ParsedArgv;
-    $parse(message: string, terminator?: string, builtin?: boolean): ParsedArgv;
-    $execute(argv: ExecuteArgv): Promise<void>;
-    $execute(message: string, next?: NextFunction): Promise<void>;
+    get database(): import("./database").Database;
+    get uid(): string;
+    get cid(): string;
+    get sid(): string;
+    send(message: string): Promise<void>;
+    cancelQueued(delay?: number): void;
+    sendQueued(content: string, delay?: number): Promise<void>;
+    private _getValue;
+    getChannel<K extends Channel.Field = never>(id?: string, assignee?: string, fields?: readonly K[]): Promise<Pick<Channel, "id" | K>>;
+    /** 在当前会话上绑定一个可观测频道实例 */
+    observeChannel<T extends Channel.Field = never>(fields?: Iterable<T>): Promise<Channel.Observed<T | G>>;
+    getUser<K extends User.Field = never>(id?: string, authority?: number, fields?: readonly K[]): Promise<any>;
+    /** 在当前会话上绑定一个可观测用户实例 */
+    observeUser<T extends User.Field = never>(fields?: Iterable<T>): Promise<User.Observed<T | U>>;
+    collect<T extends TableType>(key: T, argv: Argv, fields?: Set<keyof Tables[T]>): Set<keyof Tables[T]>;
+    resolve(argv: Argv): Command<never, never, any[], {}>;
+    execute(content: string, next?: NextFunction): Promise<string>;
+    execute(argv: Argv, next?: NextFunction): Promise<string>;
+    middleware(middleware: Middleware): () => boolean;
+    prompt(timeout?: number): Promise<unknown>;
+    suggest(options: SuggestOptions): Promise<void>;
 }
+export interface SuggestOptions {
+    target: string;
+    items: string[];
+    next?: NextFunction;
+    prefix?: string;
+    suffix: string;
+    coefficient?: number;
+    apply: (this: Session, suggestion: string, next: NextFunction) => void;
+}
+export declare function getSessionId(session: Session): string;
+export declare type FieldCollector<T extends TableType, K = keyof Tables[T], A extends any[] = any[], O = {}> = Iterable<K> | ((argv: Argv<never, never, A, O>, fields: Set<keyof Tables[T]>) => void);
 export interface AnonymousInfo {
@@ -101,9 +145,2 @@ id?: number;
 export declare type GroupRole = 'owner' | 'admin' | 'member';
-export interface SenderInfo extends StrangerInfo {
-    area?: string;
-    card?: string;
-    level?: string;
-    role?: GroupRole;
-    title?: string;
-}
 export interface StatusInfo {
@@ -117,21 +154,29 @@ appInitialized: boolean;
 }
-export interface MessageInfo {
-    id: string;
-    type: EventTypeMap['message'];
-    content: string;
-    timestamp: number;
-    sender: SenderInfo;
+export interface MessageBase {
+    messageId?: string;
+    channelId?: string;
+    groupId?: string;
+    userId?: string;
+    content?: string;
+    timestamp?: number;
+    author?: AuthorInfo;
 }
+export declare type MessageSubtype = keyof MessageType;
+export interface MessageInfo extends MessageBase {
+    subtype?: MessageSubtype;
+}
 export interface GroupInfo {
-    id: string;
+    groupId: string;
     name: string;
 }
 export interface UserInfo {
-    id: string;
+    userId: string;
     name: string;
 }
 export interface GroupMemberInfo extends UserInfo {
-    nick: string;
-    roles: string[];
+    nick?: string;
+    roles?: string[];
 }
-export declare function getTargetId(target: string | number): number;
+export interface AuthorInfo extends GroupMemberInfo {
+}
+export {};

package.json

 {
   "name": "koishi-core",
   "description": "Core features for Koishi",
-  "version": "3.0.0-alpha.0",
+  "version": "3.0.0-beta.0",
   "main": "dist/index.js",
@@ -17,4 +17,3 @@ "typings": "dist/index.d.ts",
     "lint": "eslint src --ext .ts",
-    "precommit": "yarn lint",
-    "prepack": "tsc -b"
+    "precommit": "yarn lint"
   },
@@ -46,8 +45,8 @@ "repository": {
     "fastest-levenshtein": "^1.0.12",
-    "koa": "^2.13.0",
+    "koa": "^2.13.1",
     "koa-bodyparser": "^4.3.0",
     "koa-router": "^10.0.0",
-    "koishi-utils": "^3.2.0",
+    "koishi-utils": "^3.2.1",
     "lru-cache": "^6.0.0"
   }
 }

README.md

@@ -0,0 +0,0 @@ # shiki-core

Fixed alerts

Major refactor

Supply chain risk

Package has recently undergone a major refactor. It may be unstable or indicate significant internal changes. Use caution when updating to versions that include significant changes.

Found 1 instance in 1 package

Improved metrics

Lines of code

2577

increased by8.14%

Number of medium supply chain risk alerts

1

decreased by-50%

Worsened metrics

Total package byte prevSize

225206

decreased by-10.47%

Dependency changes

• Updatedkoa@^2.13.1

• Updatedkoishi-utils@^3.2.1