@maaxyz/maa-node 2.2.2-post.11-ci.12043306412

package/src/resource.ts

@@ -0,0 +1,166 @@
+import { Context } from './context'
+import { Job, JobSource } from './job'
+import maa from './maa'
+import {
+    CustomActionCallback,
+    CustomActionSelf,
+    CustomRecognizerCallback,
+    CustomRecognizerSelf
+} from './types'
+
+export type ResourceNotify = { res_id: maa.ResId; path: string } & (
+    | {
+          msg: 'StartLoading'
+      }
+    | {
+          msg: 'LoadingCompleted' | 'LoadingFailed'
+          hash: string
+      }
+)
+
+export class ResourceBase {
+    handle: maa.ResourceHandle
+    #source: JobSource<maa.ResId>
+
+    notify(message: string, details_json: string): maa.MaybePromise<void> {}
+
+    set parsed_notify(cb: (msg: ResourceNotify) => maa.MaybePromise<void>) {
+        this.notify = (msg, details) => {
+            return cb({
+                msg: msg.replace(/^Resource\./, '') as any,
+                ...JSON.parse(details)
+            })
+        }
+    }
+
+    constructor(handle: maa.ResourceHandle) {
+        this.handle = handle
+        this.#source = {
+            status: id => maa.resource_status(this.handle, id),
+            wait: id => maa.resource_wait(this.handle, id)
+        }
+    }
+
+    destroy() {
+        maa.resource_destroy(this.handle)
+    }
+
+    set inference_device(id: 'cpu' | 'auto' | number) {
+        switch (id) {
+            case 'cpu':
+                id = -2
+                break
+            case 'auto':
+                id = -1
+                break
+        }
+        if (!maa.resource_set_option_inference_device(this.handle, id)) {
+            throw 'Resource set inference_device failed'
+        }
+    }
+
+    register_custom_recognizer(name: string, func: CustomRecognizerCallback) {
+        if (
+            !maa.resource_register_custom_recognition(
+                this.handle,
+                name,
+                (context, id, task, name, param, image) => {
+                    const self: CustomRecognizerSelf = {
+                        context: new Context(context),
+                        id,
+                        task,
+                        name,
+                        param: JSON.parse(param),
+                        image
+                    }
+                    return func.apply(self, [self])
+                }
+            )
+        ) {
+            throw 'Resource register_custom_recognition failed'
+        }
+    }
+
+    unregister_custom_recognizer(name: string) {
+        if (!maa.resource_unregister_custom_recognition(this.handle, name)) {
+            throw 'Resource unregister_custom_recognition failed'
+        }
+    }
+
+    clear_custom_recognizer() {
+        if (!maa.resource_clear_custom_recognition(this.handle)) {
+            throw 'Resource clear_custom_recognition failed'
+        }
+    }
+
+    register_custom_action(name: string, func: CustomActionCallback) {
+        if (
+            !maa.resource_register_custom_action(
+                this.handle,
+                name,
+                (context, id, task, name, param, recoId, box) => {
+                    const self: CustomActionSelf = {
+                        context: new Context(context),
+                        id,
+                        task,
+                        name,
+                        param: JSON.parse(param),
+                        recoId,
+                        box
+                    }
+                    return func.apply(self, [self])
+                }
+            )
+        ) {
+            throw 'Resource register_custom_action failed'
+        }
+    }
+
+    unregister_custom_action(name: string) {
+        if (!maa.resource_unregister_custom_action(this.handle, name)) {
+            throw 'Resource unregister_custom_action failed'
+        }
+    }
+
+    clear_custom_action() {
+        if (!maa.resource_clear_custom_action(this.handle)) {
+            throw 'Resource clear_custom_action failed'
+        }
+    }
+
+    post_path(path: string) {
+        return new Job(this.#source, maa.resource_post_path(this.handle, path))
+    }
+
+    clear() {
+        if (!maa.resource_clear(this.handle)) {
+            throw 'Resource clear failed'
+        }
+    }
+
+    get loaded() {
+        return maa.resource_loaded(this.handle)
+    }
+
+    get hash() {
+        return maa.resource_get_hash(this.handle)
+    }
+
+    get task_list() {
+        return maa.resource_get_task_list(this.handle)
+    }
+}
+
+export class Resource extends ResourceBase {
+    constructor() {
+        let ws: WeakRef<this>
+        const h = maa.resource_create((message, details_json) => {
+            ws.deref()?.notify(message, details_json)
+        })
+        if (!h) {
+            throw 'Resource create failed'
+        }
+        super(h)
+        ws = new WeakRef(this)
+    }
+}

package/src/tasker.ts

@@ -0,0 +1,229 @@
+import { ControllerBase } from './controller'
+import { Job, JobSource } from './job'
+import maa from './maa'
+import { ResourceBase } from './resource'
+
+type TaskDetail = ReturnType<TaskerBase['task_detail']>
+
+class TaskJob extends Job<maa.TaskId, JobSource<maa.TaskId>> {
+    #tasker: TaskerBase
+
+    constructor(tasker: TaskerBase, source: JobSource<maa.TaskId>, id: maa.TaskId) {
+        super(source, id)
+
+        this.#tasker = tasker
+    }
+
+    get() {
+        if (this.done) {
+            return this.#tasker.task_detail(this.id)
+        } else {
+            return null
+        }
+    }
+
+    wait() {
+        const superPro = super.wait()
+        const pro = superPro as typeof superPro & {
+            get: () => Promise<TaskDetail>
+        }
+        pro.get = () => {
+            return new Promise(resolve => {
+                pro.then(self => {
+                    resolve(self.get())
+                })
+            })
+        }
+        return pro
+    }
+}
+
+export type TaskerNotify = {
+    task_id: maa.TaskId
+    entry: string
+    hash: string
+    uuid: string
+} & (
+    | {
+          msg: 'Task.Started' | 'Task.Completed' | 'Task.Failed'
+      }
+    | {
+          msg: 'Debug.RecognitionResult' | 'Debug.Hit'
+          current: string
+          recognition: {
+              reco_id: maa.RecoId
+              name: string
+              /**
+               * Won't be `null` for msg `Debug.Hit`
+               */
+              box: maa.FlatRect | null
+              detail: string
+          }
+      }
+    | {
+          msg: 'Focus.ReadyToRun' | 'Focus.Completed' | 'Debug.ReadyToRun' | 'Debug.Completed'
+          current: string
+          node: {
+              node_id: maa.NodeId
+              name: string
+              reco_id: maa.RecoId
+              times: number
+              completed: boolean
+          }
+      }
+    | {
+          msg: 'Debug.ListToRecognize' | 'Debug.MissAll'
+          current: string
+          list: string[]
+      }
+)
+
+export class TaskerBase {
+    handle: maa.TaskerHandle
+    #source: JobSource<maa.TaskId>
+
+    notify(message: string, details_json: string): maa.MaybePromise<void> {}
+
+    set parsed_notify(cb: (msg: TaskerNotify) => maa.MaybePromise<void>) {
+        this.notify = (msg, details) => {
+            return cb({
+                msg: msg.replace(/^Task(?:er)?\./, '') as any,
+                ...JSON.parse(details)
+            })
+        }
+    }
+
+    constructor(handle: maa.TaskerHandle) {
+        this.handle = handle
+        this.#source = {
+            status: id => maa.tasker_status(this.handle, id),
+            wait: id => maa.tasker_wait(this.handle, id)
+        }
+    }
+
+    destroy() {
+        maa.tasker_destroy(this.handle)
+    }
+
+    bind(slave: ControllerBase | ResourceBase) {
+        let ret: boolean
+        if (slave instanceof ControllerBase) {
+            ret = maa.tasker_bind_controller(this.handle, slave.handle)
+        } else {
+            ret = maa.tasker_bind_resource(this.handle, slave.handle)
+        }
+        if (!ret) {
+            throw 'Tasker bind failed'
+        }
+    }
+
+    post_pipeline(entry: string, param: Record<string, unknown> = {}) {
+        return new TaskJob(
+            this,
+            this.#source,
+            maa.tasker_post_pipeline(this.handle, entry, JSON.stringify(param))
+        )
+    }
+
+    get inited() {
+        return maa.tasker_inited(this.handle)
+    }
+
+    get running() {
+        return maa.tasker_running(this.handle)
+    }
+
+    post_stop() {
+        if (!maa.tasker_post_stop(this.handle)) {
+            throw 'Tasker post_stop failed'
+        }
+    }
+
+    get resource() {
+        const res = maa.tasker_get_resource(this.handle)
+        if (res) {
+            return new ResourceBase(res)
+        } else {
+            return null
+        }
+    }
+
+    get controller() {
+        const ctrl = maa.tasker_get_controller(this.handle)
+        if (ctrl) {
+            return new ControllerBase(ctrl)
+        } else {
+            return null
+        }
+    }
+
+    clear_cache() {
+        if (!maa.tasker_clear_cache(this.handle)) {
+            throw 'Tasker clear_cache failed'
+        }
+    }
+
+    recognition_detail(id: maa.RecoId) {
+        const dt = maa.tasker_get_recognition_detail(this.handle, id)
+        if (dt) {
+            const [name, algorithm, hit, box, detail, raw, draws] = dt
+            return {
+                name,
+                algorithm,
+                hit,
+                box,
+                detail,
+                raw,
+                draws
+            }
+        } else {
+            return null
+        }
+    }
+
+    node_detail(id: maa.NodeId) {
+        const dt = maa.tasker_get_node_detail(this.handle, id)
+        if (dt) {
+            const [name, reco_id, completed] = dt
+            return {
+                name,
+                reco: this.recognition_detail(reco_id),
+                completed
+            }
+        } else {
+            return null
+        }
+    }
+
+    task_detail(id: maa.TaskId) {
+        const dt = maa.tasker_get_task_detail(this.handle, id)
+        if (dt) {
+            const [entry, node_ids, status] = dt
+            return {
+                entry,
+                nodes: node_ids.map(i => this.node_detail(i)),
+                status
+            }
+        } else {
+            return null
+        }
+    }
+
+    latest_node(task: string) {
+        return maa.tasker_get_latest_node(this.handle, task)
+    }
+}
+
+export class Tasker extends TaskerBase {
+    constructor() {
+        let ws: WeakRef<this>
+        const h = maa.tasker_create((message, details_json) => {
+            ws.deref()?.notify(message, details_json)
+        })
+        if (!h) {
+            throw 'Tasker create failed'
+        }
+        super(h)
+        ws = new WeakRef(this)
+    }
+}

package/src/types.ts

@@ -0,0 +1,30 @@
+import { Context } from './context'
+import maa from './maa'
+
+export interface CustomRecognizerSelf {
+    context: Context
+    id: maa.TaskId
+    task: string
+    name: string
+    param: unknown
+    image: maa.ImageData
+}
+
+export interface CustomActionSelf {
+    context: Context
+    id: maa.TaskId
+    task: string
+    name: string
+    param: unknown
+    recoId: maa.RecoId
+    box: maa.Rect
+}
+
+type CustomCallback<Self, Ret> = (this: Self, self: Self) => maa.MaybePromise<Ret>
+
+export type CustomRecognizerCallback = CustomCallback<
+    CustomRecognizerSelf,
+    [out_box: maa.Rect, out_detail: string] | null
+>
+
+export type CustomActionCallback = CustomCallback<CustomActionSelf, boolean>

package/tsconfig.json

@@ -0,0 +1,9 @@
+{
+    "extends": "@tsconfig/node20/tsconfig.json",
+    "compilerOptions": {
+        "outDir": "dist",
+        "declaration": true,
+        "emitDeclarationOnly": true
+    },
+    "include": ["src/**/*.ts"]
+}