index.uts

import { RequestTask, SyncOptions } from "./interface.uts";
import { log } from "./utils.uts";
export type AsyncOptions = {
    type : string;
    success : (res : string) => void;
    fail : (res : string) => void;
    complete : (res : string) => void;
};

export type {
    SyncOptions
} from "./interface.uts";

type SyntaxResult = {
    name : string
};

type SyncResult = {
    msg : string
}

/**
 * 导出一个属性
 */
export const MAX = 100;

/**
 * 导出一个同步方法
 * @returns
 */
export function testSync(msg : string) : SyncResult {
    console.log("log test");
    log("log test1");

    const res : SyncResult = {
        msg: `hello ${msg}`
    }
    return res
    // return {
    //   msg: `hello ${msg}`,
    // };
}
/**
 * 导出一个同步方法（触发了数组越界异常）
 */
export function testSyncError() {
    const arr : string[] = [];
    console.log(arr[1]);
}
/**
 * 导出一个带callback的同步方法
 * @param opts
 */
export function testSyncWithCallback(opts : AsyncOptions) : SyntaxResult {
    if (opts.type == "success") {
        opts.success("success");
    } else {
        opts.fail("fail");
    }
    opts.complete("complete");

    const res : SyntaxResult = {
        name: "testSyncWithCallback"
    }
    return res;
    // return { name: "testSyncWithCallback" };
}



async function testAwaitPromise(res : SyntaxResult) : Promise<SyntaxResult> {
    // #ifdef APP-ANDROID
    return await new Promise(function (resolve : (res : SyntaxResult) => void) {
        resolve(res)
    })
    // #endif
    // #ifndef APP-ANDROID
    return res
    // #endif
}
/**
 * 导出一个异步方法
 * @returns
 */
export async function testAsync(opts : AsyncOptions) : Promise<SyntaxResult> {
    if (opts.type == "success") {
        opts.success("success");
    } else {
        opts.fail("fail");
    }
    opts.complete("complete");

    const res : SyntaxResult = {
        name: "testAsync"
    }
    return await testAwaitPromise(res);
    // return { name: "testAsync" };
}

export type TestOptions = {
    name : string;
    callback : (res : string) => void;
};

export class Test {
    id : number;
    name : string;
    static type : string = "Test";
    constructor(id : number, options : TestOptions) {
        this.id = id;
        this.name = options.name;
        options.callback("Test.constructor");
    }
    static testClassStaticSyncWithCallback(opts : AsyncOptions) : SyntaxResult {
        return testSyncWithCallback(opts);
    }
    static async testClassStaticAsync(opts : AsyncOptions) : Promise<SyntaxResult> {
        const res = await testAsync(opts);
        return res;
    }
    testClassSyncWithCallback(opts : AsyncOptions) : SyntaxResult {
        return testSyncWithCallback(opts);
    }
    async testClassAsync(opts : AsyncOptions) : Promise<SyntaxResult> {
        const res = await testAsync(opts);
        return res;
    }
}

class RequestTaskImpl implements RequestTask {
    url : string
    constructor(url : string) {
        this.url = url
    }
    abort() : RequestTask {
        return this
    }
    onCallback(callback : (res : string) => void) {
        callback("onCallback")
    }
    sync(options : SyncOptions) : string {
        options.success?.("success")
        options.complete?.("success")
        return "sync"
    }
}

export function request(url : string) : RequestTask | null {
    return new RequestTaskImpl(url)
}