JsExt

function _try<E = unknown, R = any, A extends any[] = any[]>(
    fn: (...args: A) => R,
    ...args: A
): [E, R];
function _try<E = unknown, R = any, A extends any[] = any[]>(
    fn: (...args: A) => Promise<R>,
    ...args: A
): Promise<[E, R]>;

const [err, res] = _try(() => {
    // do something that may fail
});

let [err, res] = await _try(async () => {
    return await axios.get("https://example.org");
});

if (err) {
    res = (err as any)["response"];
}

function _try<E = unknown, R = any>(job: Promise<R>): Promise<[E, R]>;

let [err, res] = await _try(axios.get("https://example.org"));

if (err) {
    res = (err as any)["response"];
}

function _try<E = unknown, T = any, A extends any[] = any[], TReturn = any, TNext = unknown>(
    fn: (...args: A) => Generator<T, TReturn, TNext>,
    ...args: A
): Generator<[E, T], [E, TReturn], TNext>;
function _try<E = unknown, T = any, A extends any[] = any[], TReturn = any, TNext = unknown>(
    fn: (...args: A) => AsyncGenerator<T, TReturn, TNext>,
    ...args: A
): AsyncGenerator<[E, T], [E, TReturn], TNext>;

const iter = _try(function* () {
    // do something that may fail
});

for (const [err, val] of iter) {
    if (err) {
        console.error("something went wrong:", err);
    } else {
        console.log("current value:", val);
    }
}

const iter = _try(async function* () {
    // do something that may fail
});

for await (const [err, val] of iter) {
    if (err) {
        console.error("something went wrong:", err);
    } else {
        console.log("current value:", val);
    }
}

function _try<E = unknown, T = any, TReturn = any, TNext = unknown>(
    gen: Generator<T, TReturn, TNext>
): Generator<[E, T], [E, TReturn], TNext>;
function _try<E = unknown, T = any, TReturn = any, TNext = unknown>(
    gen: AsyncGenerator<T, TReturn, TNext>
): AsyncGenerator<[E, T], [E, TReturn], TNext>;

const iter = Number.sequence(1, 10);

for (const [err, val] of _try(iter)) {
    if (err) {
        console.error("something went wrong:", err);
    } else {
        console.log("current value:", val);
    }
}

async function* gen() {
    // do something that may fail
};

for await (const [err, val] of _try(gen())) {
    if (err) {
        console.error("something went wrong:", err);
    } else {
        console.log("current value:", val);
    }
}

function func<T, R = any, A extends any[] = any[]>(
    fn: (this: T, defer: (cb: () => void) => void, ...args: A) => R
): (this: T, ...args: A) => R;

const getVersion = func(async (defer) => {
    const file = await fs.open("./package.json", "r");
    defer(() => file.close());

    const content = await file.readFile("utf8");
    const pkg = JSON.parse(content);

    return pkg.version as string;
});

function wrap<T, Fn extends (this: T, ...args: any[]) => any>(
    fn: Fn,
    wrapper: (this: T, fn: Fn, ...args: Parameters<Fn>) => ReturnType<Fn>
): Fn

function log(text: string) {
    console.log(text);
}

const show = wrap(log, function (fn, text) {
    return fn.call(this, new Date().toISOString() + " " + text);
});

console.log(show.name); // log
console.log(show.length); // 1
console.assert(show.toString() === log.toString());

function throttle<T, Fn extends (this: T, ...args: any[]) => any>(
    handler: Fn,
    duration: number
): Fn;
function throttle<T, Fn extends (this: T, ...args: any[]) => any>(handler: Fn, options: {
    duration: number;
    /**
     * Use the throttle strategy `for` the given key, this will keep the result in a global
     * cache, binding new `handler` function for the same key will result in the same result
     * as the previous, unless the duration has passed. This mechanism guarantees that both
     * creating the throttled function in function scopes and overwriting the handler are
     * possible.
     */
    for?: any;
    /**
     * When turned on, respond with the last cache (if available) immediately, even if it has
     * expired, and update the cache in the background.
     */
    noWait?: boolean;
}): Fn;

const fn = throttle((input: string) => input, 1_000);
console.log(fn("foo")); // foo
console.log(fn("bar")); // foo

await Promise.sleep(1_000);
console.log(fn("bar")); // bar

const out1 = await throttle(() => Promise.resolve("foo"), { duration: 1_000, for: "example" })();
console.log(out1); // foo

const out2 = await throttle(() => Promise.resolve("bar"), { duration: 1_000, for: "example" })();
console.log(out2); // foo

await Promise.sleep(1_000);
const out3 = await throttle(() => Promise.resolve("bar"), { duration: 1_000, for: "example" })();
console.log(out3); // bar

function mixins<T extends Constructor<any>, M extends any[]>(
    base: T,
    ...mixins: { [X in keyof M]: Constructor<M[X]> }
): T & Constructor<UnionToIntersection<FlatArray<M, 1>>>;
function mixins<T extends Constructor<any>, M extends any[]>(
    base: T,
    ...mixins: M
): T & Constructor<UnionToIntersection<FlatArray<M, 1>>>;

class Log {
    log(text: string) {
        console.log(text);
    }
}

class View {
    display(data: Record<string, any>[]) {
        console.table(data);
    }
}

class Controller extends mixins(View, Log) {
    constructor(readonly topic: string) {
        super();
    }
}

const ctrl = new Controller("foo");
ctrl.log("something is happening");
ctrl.display([{ topic: ctrl.topic, content: "something is happening" }]);

console.assert(isSubclassOf(Controller, View));
console.assert(!isSubclassOf(Controller, Log));

function isSubclassOf<T, B>(ctor1: Constructor<T>, ctor2: Constructor<B>): boolean;

class Moment extends Date {}

console.assert(isSubclassOf(Moment, Date));
console.assert(isSubclassOf(Moment, Object)); // all classes are subclasses of Object

function chan<T>(capacity?: number): Channel<T>;

const channel = chan<number>();

(async () => {
    await channel.push(123);
})();

const num = await channel.pop();
console.log(num);
// output:
// 123

const channel = chan<number>(3);

await channel.push(123);
await channel.push(456);
await channel.push(789);

const num1 = await channel.pop();
const num2 = await channel.pop();
const num3 = await channel.pop();

console.log(num1);
console.log(num2);
console.log(num3);
// output:
// 123
// 456
// 789

const channel = chan<number>();

(async () => {
    for (const num of Number.sequence(1, 5)) {
        await channel.push(num);
    }

    channel.close();
})();

for await (const num of channel) {
    console.log(num);
}
// output:
// 1
// 2
// 3
// 4
// 5

function queue<T>(handler: (data: T) => Promise<void>, bufferSize?: number): Queue<T>

const list: string[] = [];
const q = queue(async (str: string) => {
    await Promise.resolve(null);
    list.push(str);
});

q.onError(err => {
    console.error(err);
});

await q.push("foo");
await q.push("foo");

console.log(list.length);
q.close();
// output:
// 2

function read<I extends AsyncIterable<any>>(iterable: I): I;
function read(es: EventSource, options?: { event?: string; }): AsyncIterable<string>;
function read<T extends Uint8Array | string>(ws: WebSocket): AsyncIterable<T>;
function read<T>(target: EventTarget, eventMap?: {
    message?: string;
    error?: string;
    close?: string;
}): AsyncIterable<T>;
function read<T>(target: NodeJS.EventEmitter, eventMap?: {
    data?: string;
    error?: string;
    close?: string;
}): AsyncIterable<T>;

// listen to the `onmessage`
const sse = new EventSource("/sse/message");

for await (const msg of read(sse)) {
    console.log("receive message:", msg);
}

// listen to a specific event
const channel = new EventSource("/sse/broadcast");

for await (const msg of read(channel, { event: "broadcast" })) {
    console.log("receive message:", msg);
}

const ws = new WebSocket("/ws");

for await (const data of read(ws)) {
    if (typeof data === "string") {
        console.log("receive text message:", data);
    } else {
        console.log("receive binary data:", data);
    }
}

for await (const msg of read(self)) {
    console.log("receive message from the parent window:", msg);
}

for await (const msg of read(process)) {
    console.log("receive message from the parent process:", msg);
}

function readAll<T>(iterable: AsyncIterable<T>): Promise<T[]>;

const file = fs.createReadStream("./package.json");
const chunks = await readAll(file);

function parallel<M extends { [x: string]: any; }>(
    mod: string | (() => Promise<M>),
    options?: {
        /**
         * Choose whether to use `worker_threads` or `child_process` for creating the worker
         * thread. The default setting is `worker_threads`.
         * 
         * In browsers and Deno, this option is ignored and will always use the web worker.
         * 
         * We should always consider using `worker_threads` over `child_process` since it consumes
         * less system resources. However, As I've tested, `process.send(json)` performs about
         * 20% ~ 30% more efficient than `postMessage()`, so `child_process` along with `json`
         * serialization may suits more for some edge scenarios. 
         */
        adapter?: "worker_threads" | "child_process";
        /**
         * When using `child_process` adapter, this option instructs which serialization algorithm
         * should be used to serialize the data for transferring between the parent and the child
         * process. The default setting is `advanced` (structured clone algorithm).
         * 
         * NOTE: this option only works in Node.js, Bun doesn't support `json` serialization and
         * will always use `advanced`.
         */
        serialization?: "advanced" | "json";
    }
): ThreadedFunctions<M>;

const mod = parallel(() => import("./examples/worker.mjs"));
console.log(await mod.greet("World")); // Hi, World

const mod = parallel(() => import("./examples/worker.mjs"));

for await (const word of mod.sequence(["foo", "bar"])) {
    console.log(word);
}
// output:
// foo
// bar

const mod = parallel(() => import("./examples/worker.mjs"));

const channel = chan<number>();
const length = mod.twoTimesValues(channel);

for (const value of Number.sequence(0, 9)) {
    await channel.push({ value, done: value === 9 });
}

const results = (await readAll(channel)).map(item => item.value);
console.log(results);
console.log(await length);
// output:
// [0, 2, 4, 6, 8, 10, 12, 14, 16, 18]
// 10

const mod = parallel<typeof import("./examples/worker.mjs")>("./examples/worker.mjs");

namespace parallel {
    /**
     * The maximum number of workers allowed to exist at the same time.
     * 
     * In Bun, Deno and browsers, the default value is set to
     * `navigator.hardwareConcurrency`.
     * 
     * In Node.js, the default value is `16`.
     */
    export var maxWorkers: number;

    /**
     * In browsers, by default, the program loads the worker entry directly from GitHub,
     * which could be slow due to poor internet connection, we can copy the entry file
     * `bundle/worker.mjs` to a local path of our website and set this option to that path
     * so that it can be loaded locally.
     * 
     * Or, if the code is bundled, the program won't be able to automatically locate the entry
     * file in the file system, in such case, we can also copy the entry file
     * (`bundle/worker.mjs` for Bun, Deno and the browser, `bundle/worker-node.mjs` for Node.js)
     * to a local directory and supply this option instead.
     */
    export var workerEntry: string | undefined;

    /**
     * Marks the given data to be transferred instead of cloned to the worker thread.
     * Once transferred, the data is no longer available on the sending end.
     * 
     * Currently, only `ArrayBuffer` are guaranteed to be transferable across all supported
     * JavaScript runtimes.
     * 
     * Be aware, the transferable object can only be used as a parameter, return a transferable
     * object from the threaded function is not supported and will always be cloned.
     * 
     * NOTE: always prefer channel for transferring large amount of data in streaming fashion
     * than sending them as transferrable objects, it consumes less memory and does not transfer
     * the ownership of the data.
     */
    export function transfer<T extends Transferable>(data: T): T;
}

const mod = parallel(() => import("./examples/worker.mjs"));

const arr = Uint8Array.from([0, 1, 2]);
const length = await mod.transfer(parallel.transfer(arr.buffer));

console.assert(length === 3);
console.assert(arr.byteLength === 0);

function run<R, A extends any[] = any[]>(script: string, args?: A, options?: {
    /** If not set, invoke the default function, otherwise invoke the specified function. */
    fn?: string;
    /** Automatically abort the task when timeout (in milliseconds). */
    timeout?: number;
    /**
     * Instead of dropping the worker after the task has completed, keep it alive so that it can
     * be reused by other tasks.
     */
    keepAlive?: boolean;
    /**
     * Choose whether to use `worker_threads` or `child_process` for running the script.
     * The default setting is `worker_threads`.
     * 
     * In browsers and Deno, this option is ignored and will always use the web worker.
     */
    adapter?: "worker_threads" | "child_process";
    /**
     * When using `child_process` adapter, this option instructs which serialization algorithm
     * should be used to serialize the data for transferring between the parent and the child
     * process. The default setting is `advanced` (structured clone algorithm).
     * 
     * NOTE: this option only works in Node.js, Bun doesn't support `json` serialization and
     * will always use `advanced`.
     */
    serialization?: "advanced" | "json";
}): Promise<{
    workerId: number;
    /** Retrieves the return value of the function that has been called.. */
    result(): Promise<R>;
    /** Iterates the yield value if the function returns a generator. */
    iterate(): AsyncIterable<R>;
    /** Terminates the worker thread and aborts the task. */
    abort(reason?: unknown): Promise<void>;
}>;

const job1 = await run<string, [string]>("examples/worker.mjs", ["World"]);
console.log(await job1.result()); // Hello, World

const job2 = await run<string, [string[]]>("examples/worker.mjs", [["foo", "bar"]], {
    fn: "sequence",
});
for await (const word of job2.iterate()) {
    console.log(word);
}
// output:
// foo
// bar

const job3 = await run<string, [string]>("examples/worker.mjs", ["foobar"], {
    fn: "takeTooLong",
});
await job3.abort();
const [err, res] = await _try(job3.result());
console.assert(err === null);
console.assert(res === undefined);

function example<T, A extends any[] = any[]>(
    fn: (this: T, console: Console, ...args: A) => void | Promise<void>,
    options?: {
        /** Suppress logging to the terminal and only check the output. */
        suppress?: boolean;
    }
): (this: T, ...args: A) => Promise<void>;

it("should output as expected", example(console => {
    console.log("Hello, World!");
    // output:
    // Hello, World!
}));

function deprecate<T, Fn extends (this: T, ...args: any[]) => any>(
    fn: Fn,
    tip?: string,
    once?: boolean
): Fn;

const sum = deprecate(function sum(a: number, b: number) {
    return a + b;
}, "use `a + b` instead");
console.log(sum(1, 2));
// output:
// DeprecationWarning: sum() is deprecated, use `a + b` instead (at <anonymous>:4:13)
// 3

function deprecate(target: string, forFn: Function, tip?: string, once?: boolean): void;

const pow = function pow(a: number, b: number) {
    deprecate("pow()", pow, "use `a ** b` instead");
    return a ** b;
};
console.log(pow(2, 3));
// output:
// DeprecationWarning: pow() is deprecated, use `a ** b` instead (at <anonymous>:5:13)
// 8

import { parseAs } from "@ayonli/jsext/json";
// or
import "@ayonli/jsext/json/augment";