ciorent 1.0.4 → 1.0.5

package/scripts/report-size.ts

@@ -0,0 +1,33 @@
+import { minify } from 'oxc-minify';
+import { LIB } from './utils.ts';
+
+const toByte = (num: number) =>
+  num >= 1e3 ? (num / 1e3).toFixed(2) + 'KB' : num + 'B';
+
+const arr = await Promise.all(
+  [...new Bun.Glob('**/*.js').scanSync(LIB)].map(async (path) => {
+    const file = Bun.file(LIB + '/' + path);
+    const code = await file.text();
+    const minfiedCode = minify(path, code).code!;
+
+    return {
+      entry: path,
+      size: file.size,
+      minified: Buffer.from(minfiedCode).byteLength,
+      gzip: Bun.gzipSync(code).byteLength,
+      minifiedGzip: Bun.gzipSync(minfiedCode).byteLength,
+    };
+  }),
+);
+
+console.table(
+  arr
+    .sort((a, b) => a.size - b.size)
+    .map((val) => ({
+      Entry: val.entry,
+      Size: toByte(val.size),
+      Minify: toByte(val.minified),
+      GZIP: toByte(val.gzip),
+      'Minify GZIP': toByte(val.minifiedGzip),
+    })),
+);

package/scripts/task.ts

@@ -0,0 +1,8 @@
+import { SCRIPTS } from './utils.ts';
+
+const task = process.argv[2];
+if (task == null) throw new Error('A task must be specified!');
+
+await Bun.$`bun run ${{
+  raw: SCRIPTS + '/' + task + '.ts',
+}} ${process.argv.slice(3)}`;

package/scripts/tsconfig.json

@@ -0,0 +1,12 @@
+{
+  "extends": "../tsconfig.json",
+  "compilerOptions": {
+    "isolatedModules": false,
+    "isolatedDeclarations": false,
+    "allowJs": true,
+    "paths": {
+      "ciorent": ["../src"],
+      "ciorent/*": ["../src/*"]
+    }
+  }
+}

package/scripts/tsconfig.ts

@@ -0,0 +1,16 @@
+import { join, relative } from 'node:path';
+import { SCRIPTS } from './utils.ts';
+
+const paths = process.argv.slice(2);
+
+for (const path of paths)
+  Bun.write(
+    join(path, 'tsconfig.json'),
+    JSON.stringify(
+      {
+        extends: relative(path, SCRIPTS + '/tsconfig.json'),
+      },
+      null,
+      2,
+    ),
+  );

package/scripts/utils.ts

@@ -0,0 +1,15 @@
+import { join, resolve } from 'node:path/posix';
+import { $, file, write } from 'bun';
+
+export const SCRIPTS = import.meta.dir;
+export const ROOT = resolve(SCRIPTS, '..');
+export const SOURCE = ROOT + '/src';
+export const LIB = ROOT + '/lib';
+export const BENCH = ROOT + '/bench';
+export const EXAMPLES = ROOT + '/examples/src';
+
+export const cp = (from: string, to: string, path: string) =>
+  write(join(to, path), file(join(from, path)));
+export const exec = (...args: Parameters<typeof $>) =>
+  $(...args).catch((err) => process.stderr.write(err.stderr as any));
+export const cd = (dir: string) => $.cwd(dir);

package/src/index.ts

@@ -0,0 +1,96 @@
+import {
+  loadedReject,
+  loadedResolve,
+  loadResolve,
+  loadResolvers,
+} from './utils.js';
+
+/**
+ * Continue the execution on next event loop cycle.
+ *
+ * You can `await` this **occasionally** in an expensive synchronous operation to avoid
+ * blocking the main thread and let other asynchronous task to run.
+ */
+export const nextTick: Promise<void> = Promise.resolve();
+
+const getFinishedState = async (s: [number], p: Promise<any>) => {
+  try {
+    await p;
+    s[0] = 1;
+  } catch (e) {
+    s[0] = 0;
+
+    // Don't swallow error
+    return p;
+  }
+};
+/**
+ * Get the state of a promise on next tick:
+ * - `0`: Input promise rejected
+ * - `1`: Input promise resolves
+ * - `2`: Input promise pending
+ */
+export const state = async (p: Promise<any>): Promise<0 | 1 | 2> => {
+  const res = [2] as [0 | 1 | 2];
+  getFinishedState(res, p);
+  await nextTick;
+  return res[0] as any;
+};
+
+/**
+ * Check whether a value is awaitable
+ * @param p
+ * @returns
+ */
+export const isThenable = <T>(p: unknown): p is PromiseLike<T> =>
+  p !== null &&
+  typeof p === 'object' &&
+  !Array.isArray(p) &&
+  // @ts-ignore
+  typeof p.then === 'function';
+
+/**
+ * Timeout a promise
+ * @param p
+ * @param ms
+ */
+export const timeout = <T>(p: Promise<T>, ms: number): Promise<T | void> => {
+  const promise = new Promise<void>(loadResolvers);
+  setTimeout(loadedResolve, ms);
+  p.then(loadedResolve, loadedReject);
+  return promise;
+};
+
+/**
+ * Sleep for a duration.
+ * @param ms - Sleep duration in milliseconds
+ */
+export const sleep: (ms: number) => Promise<void> =
+  globalThis.Bun?.sleep ??
+  globalThis.process?.getBuiltinModule?.('timers/promises').setTimeout ??
+  ((ms) => {
+    const promise = new Promise(loadResolve);
+    setTimeout(loadedResolve, ms);
+    return promise;
+  });
+
+const sharedBuf = new Int32Array(new SharedArrayBuffer(4));
+
+/**
+ * Sleep for a duration synchronously.
+ *
+ * This method blocks the current thread.
+ *
+ * On the browser it only works in workers.
+ * @param ms - Sleep duration in milliseconds
+ */
+export const sleepSync: (ms: number) => void =
+  globalThis.Bun?.sleepSync ??
+  ((ms) => {
+    Atomics.wait(sharedBuf, 0, 0, ms);
+  });
+
+export * as mutex from './mutex.js';
+export * as limit from './rate-limit.js';
+export * as semaphore from './semaphore.js';
+export * as signal from './signal.js';

package/src/mutex.ts

@@ -0,0 +1,44 @@
+import { nextTick } from './index.js';
+import { type Extend, loadedResolve, loadResolve } from './utils.js';
+
+/**
+ * Describe a mutex.
+ */
+export type Mutex = [Promise<void>];
+
+/**
+ * Create a mutex.
+ */
+export const init = (): Mutex => [nextTick];
+
+/**
+ * Acquire a mutex.
+ */
+export const acquire = async (mu: Extend<Mutex>): Promise<() => void> => {
+  const currentLock = mu[0];
+  mu[0] = new Promise<void>(loadResolve);
+
+  const release = loadedResolve;
+  await currentLock;
+  return release;
+};
+
+const chainLock = async (
+  lock: Promise<void>,
+  fn: any,
+  ...args: any[]
+): Promise<any> => {
+  try {
+    await lock;
+  } finally {
+    return fn(...args);
+  }
+};
+/**
+ * Automatically acquire and run a task.
+ */
+export const run = <const T extends (...args: any[]) => Promise<any>>(
+  mu: Extend<Mutex>,
+  fn: T,
+  ...args: Parameters<T>
+): ReturnType<T> => (mu[0] = chainLock(mu[0], fn, ...args) as any);

package/src/rate-limit.ts

@@ -0,0 +1,64 @@
+/**
+ * Describe a rate limiter
+ */
+export type Limiter = (limit: number, ms: number) => () => boolean;
+
+/**
+ * Fixed window strategy
+ * @param limit
+ * @param ms
+ */
+export const fixedWindow: Limiter = (limit, ms) => {
+  let cur = limit;
+  const unlock = () => {
+    cur = limit;
+  };
+
+  return () => {
+    if (cur === 0) return false;
+    if (cur-- === limit) setTimeout(unlock, ms);
+
+    return true;
+  };
+};
+
+/**
+ * Sliding window strategy
+ * @param limit
+ * @param ms
+ */
+export const slidingWindow: Limiter = (limit, ms) => {
+  let cur = limit;
+  const unlock = () => {
+    cur++;
+  };
+
+  return () => {
+    if (cur === 0) return false;
+
+    cur--;
+    setTimeout(unlock, ms);
+    return true;
+  };
+};
+
+/**
+ * Token bucket strategy
+ * @param limit
+ * @param ms
+ */
+export const tokenBucket: Limiter = (limit, ms) => {
+  let cur = limit;
+
+  ms /= limit;
+  const unlock = () => {
+    if (cur++ < limit) setTimeout(unlock, ms);
+  };
+
+  return () => {
+    if (cur === 0) return false;
+    if (cur-- === limit) setTimeout(unlock, ms);
+
+    return true;
+  };
+};

package/src/semaphore.ts

@@ -0,0 +1,74 @@
+import { type Extend, loadedResolve, loadResolve } from './utils.js';
+
+type QueueItem = () => void;
+type Queue = [(QueueItem | null)[], len: number, head: number, tail: number];
+
+const push = (qu: Extend<Queue>, item: QueueItem): void => {
+  const tail = qu[3];
+  qu[3] = tail + 1 === qu[1] ? 0 : tail + 1;
+  qu[0][tail] = item;
+};
+
+/**
+ * Check whether the semaphore queue is full.
+ */
+export const full = (qu: Extend<Queue>): boolean =>
+  qu[2] === qu[3] && qu[0][qu[2]] !== null;
+
+const pop = (qu: Extend<Queue>): QueueItem => {
+  const head = qu[2];
+  qu[2] = head + 1 === qu[1] ? 0 : head + 1;
+
+  const val = qu[0][head];
+  qu[0][head] = null;
+  return val!;
+};
+
+export type Semaphore = [...Queue, remain: number];
+
+/**
+ * Create a semaphore.
+ *
+ * @example
+ * // maximum of 10 concurrent tasks and 200 waiting tasks.
+ * const sem = semaphore.init(10, 200);
+ */
+export const init = (permits: number, capacity: number): Semaphore => [
+  new Array(capacity).fill(null),
+  capacity,
+  0,
+  0,
+  permits,
+];
+
+/**
+ * Acquire a permit.
+ *
+ * @example
+ *
+ * if (semaphore.full(sem)) {
+ *   // Internal queue is full
+ * }
+ *
+ * await semaphore.acquire(sem);
+ *
+ * // Do something and then release the permit.
+ * semaphore.release(sem);
+ */
+export const acquire = (sem: Extend<Semaphore>): Promise<void> | void => {
+  if (--sem[4] < 0) {
+    const promise = new Promise<void>(loadResolve);
+    push(sem, loadedResolve);
+    return promise;
+  }
+};
+
+/**
+ * Release a permit.
+ *
+ * @example
+ * semaphore.release(sem);
+ */
+export const release = (sem: Extend<Semaphore>): void => {
+  sem[4]++ < 0 && pop(sem)();
+};

package/src/signal.ts

@@ -0,0 +1,71 @@
+/**
+ * Describe a signal
+ */
+export type Signal = [interrupted: boolean, ...parents: Signal[]];
+
+/**
+ * Create a signal
+ */
+export const init = (): Signal => [false];
+
+/**
+ * Create a signal that aborts when any of the input signals abort
+ * @param sigs
+ */
+export const any = (signals: Signal[]): Signal => {
+  const sig: Signal = [false];
+  for (let i = 0; i < signals.length; i++) signals[i].push(sig);
+  return sig;
+};
+
+const _ = [false];
+/**
+ * Create a signal that when interrupted will interrupt a group of other signals
+ */
+export const group = (signals: Signal[]): Signal =>
+  _.concat(signals as any) as any;
+
+/**
+ * Check whether the signal has been aborted
+ * @param t
+ */
+export const aborted = (t: Signal): boolean => t[0];
+
+/**
+ * Abort a signal
+ * @param t
+ */
+export const abort = (t: Signal): void => {
+  if (!t[0]) {
+    t[0] = true;
+    if (t.length > 1) for (let i = 1; i < t.length; i++) abort(t[i] as Signal);
+  }
+};
+
+/**
+ * Abort a signal after a duration
+ * @param t
+ */
+export const abortAfter = (ms: number, t: Signal): void => {
+  setTimeout(() => abort(t), ms);
+};
+
+/**
+ * Create a signal that aborts after ms
+ * @param ms
+ */
+export const timeout = (ms: number): Signal => {
+  const sig: Signal = [false];
+  abortAfter(ms, sig);
+  return sig;
+};
+
+/**
+ * Attach a signal to a `DisposableStack` or `AsyncDisposableStack`
+ */
+export const adopt = (
+  t: Signal,
+  stack: DisposableStack | AsyncDisposableStack,
+): void => {
+  stack.adopt(t, abort);
+};

package/src/utils.ts

@@ -0,0 +1,16 @@
+export type Extend<T extends any[]> = [...T, ...any[]];
+
+export let loadedResolve: (res?: any) => void;
+export let loadedReject: (reason?: any) => void;
+
+export const loadResolvers = (
+  res: (value?: any) => void,
+  rej: (reason?: any) => void,
+): void => {
+  loadedResolve = res;
+  loadedReject = rej;
+};
+
+export const loadResolve = (res: (value?: any) => void): void => {
+  loadedResolve = res;
+};

package/tsconfig.json

@@ -0,0 +1,42 @@
+{
+  "compilerOptions": {
+    // Enable latest features
+    "lib": [
+      "ESNext.AsyncIterable",
+      "ES2015.Iterable",
+      "ESNext",
+      "DOM",
+      "DOM.Iterable",
+      "DOM.AsyncIterable",
+      "WebWorker.ImportScripts",
+      "Webworker.Iterable",
+      "WebWorker.AsyncIterable"
+    ],
+    "target": "ESNext",
+
+    // Module
+    "module": "Preserve",
+    "moduleDetection": "force",
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "moduleResolution": "Bundler",
+    "allowImportingTsExtensions": true,
+    "verbatimModuleSyntax": true,
+
+    // Best practices
+    "strict": true,
+    "skipLibCheck": true,
+    "noUnusedLocals": false,
+    "noImplicitAny": true,
+    "noImplicitOverride": true,
+    "noImplicitThis": true,
+    "noUnusedParameters": false,
+    "noFallthroughCasesInSwitch": true,
+    "noPropertyAccessFromIndexSignature": false,
+
+    // Declaration
+    "declaration": true,
+    "isolatedDeclarations": true,
+    "emitDeclarationOnly": true
+  }
+}

package/index.d.ts

@@ -1,44 +0,0 @@
-/**
-* Continue the execution on next event loop cycle.
-*
-* You can `await` this **occasionally** in an expensive synchronous operation to avoid
-* blocking the main thread and let other asynchronous task to run.
-*/
-export declare const nextTick: Promise<void>;
-/**
-* Get the state of a promise on next tick:
-* - `0`: Input promise rejected
-* - `1`: Input promise resolves
-* - `2`: Input promise pending
-*/
-export declare const state: (p: Promise<any>) => Promise<0 | 1 | 2>;
-/**
-* Check whether a value is awaitable
-* @param p
-* @returns
-*/
-export declare const isThenable: <T>(p: unknown) => p is PromiseLike<T>;
-/**
-* Timeout a promise
-* @param p
-* @param ms
-*/
-export declare const timeout: <T>(p: Promise<T>, ms: number) => Promise<T | void>;
-/**
-* Sleep for a duration.
-* @param ms - Sleep duration in milliseconds
-*/
-export declare const sleep: (ms: number) => Promise<void>;
-/**
-* Sleep for a duration synchronously.
-*
-* This method blocks the current thread.
-*
-* On the browser it only works in workers.
-* @param ms - Sleep duration in milliseconds
-*/
-export declare const sleepSync: (ms: number) => void;
-export * as mutex from "./mutex.js";
-export * as limit from "./rate-limit.js";
-export * as semaphore from "./semaphore.js";
-export * as signal from "./signal.js";

package/index.js

@@ -1 +0,0 @@
-import{loadedReject,loadedResolve,loadResolve,loadResolvers}from"./utils.js";export let nextTick=Promise.resolve();let getFinishedState=async(s,p)=>{try{await p;s[0]=1}catch(e){s[0]=0;return p}};export let state=async p=>{let res=[2];getFinishedState(res,p);await nextTick;return res[0]};export let isThenable=p=>p!==null&&typeof p===`object`&&!Array.isArray(p)&&typeof p.then===`function`;let resolvePromise=async(res,rej,p)=>{try{res(await p)}catch(e){rej(e)}};export let timeout=(p,ms)=>{let promise=new Promise(loadResolvers);setTimeout(loadedResolve,ms);resolvePromise(loadedResolve,loadedReject,p);return promise};export let sleep=globalThis.Bun?.sleep??globalThis.process?.getBuiltinModule?.(`timers/promises`).setTimeout??(ms=>{let promise=new Promise(loadResolve);setTimeout(loadedResolve,ms);return promise});let sharedBuf=new Int32Array(new SharedArrayBuffer(4));export let sleepSync=globalThis.Bun?.sleepSync??(ms=>{Atomics.wait(sharedBuf,0,0,ms)});export*as mutex from"./mutex.js";export*as limit from"./rate-limit.js";export*as semaphore from"./semaphore.js";export*as signal from"./signal.js";

package/mutex.d.ts

@@ -1,17 +0,0 @@
-import { type Extend } from "./utils.js";
-/**
-* Describe a mutex.
-*/
-export type Mutex = [Promise<void>];
-/**
-* Create a mutex.
-*/
-export declare const init: () => Mutex;
-/**
-* Acquire a mutex.
-*/
-export declare const acquire: (mu: Extend<Mutex>) => Promise<() => void>;
-/**
-* Automatically acquire and run a task.
-*/
-export declare const run: <const T extends (...args: any[]) => Promise<any>>(mu: Extend<Mutex>, fn: T, ...args: Parameters<T>) => ReturnType<T>;

package/mutex.js

@@ -1 +0,0 @@
-import{nextTick}from"./index.js";import{chainLock,loadedResolve,loadResolve}from"./utils.js";export let init=()=>[nextTick];export let acquire=async mu=>{let currentLock=mu[0];mu[0]=new Promise(loadResolve);let release=loadedResolve;await currentLock;return release};export let run=(mu,fn,...args)=>mu[0]=chainLock(mu[0],fn,...args);

package/rate-limit.d.ts

@@ -1,22 +0,0 @@
-/**
-* Describe a rate limiter
-*/
-export type Limiter = (limit: number, ms: number) => () => boolean;
-/**
-* Fixed window strategy
-* @param limit
-* @param ms
-*/
-export declare const fixedWindow: Limiter;
-/**
-* Sliding window strategy
-* @param limit
-* @param ms
-*/
-export declare const slidingWindow: Limiter;
-/**
-* Token bucket strategy
-* @param limit
-* @param ms
-*/
-export declare const tokenBucket: Limiter;

package/rate-limit.js

@@ -1 +0,0 @@
-export let fixedWindow=(limit,ms)=>{let cur=limit;let unlock=()=>{cur=limit};return()=>{if(cur===0)return false;if(cur--===limit)setTimeout(unlock,ms);return true}};export let slidingWindow=(limit,ms)=>{let cur=limit;let unlock=()=>{cur++};return()=>{if(cur===0)return false;cur--;setTimeout(unlock,ms);return true}};export let tokenBucket=(limit,ms)=>{let cur=limit;ms/=limit;let unlock=()=>{if(cur++<limit)setTimeout(unlock,ms)};return()=>{if(cur===0)return false;if(cur--===limit)setTimeout(unlock,ms);return true}};

package/semaphore.d.ts

@@ -1,39 +0,0 @@
-import { type Extend } from "./utils.js";
-type QueueItem = () => void;
-type Queue = [(QueueItem | null)[], len: number, head: number, tail: number];
-/**
-* Check whether the semaphore queue is full.
-*/
-export declare const full: (qu: Extend<Queue>) => boolean;
-export type Semaphore = [...Queue, remain: number];
-/**
-* Create a semaphore.
-*
-* @example
-* // maximum of 10 concurrent tasks and 200 waiting tasks.
-* const sem = semaphore.init(10, 200);
-*/
-export declare const init: (permits: number, capacity: number) => Semaphore;
-/**
-* Acquire a permit.
-*
-* @example
-*
-* if (semaphore.full(sem)) {
-*   // Internal queue is full
-* }
-*
-* await semaphore.acquire(sem);
-*
-* // Do something and then release the permit.
-* semaphore.release(sem);
-*/
-export declare const acquire: (sem: Extend<Semaphore>) => Promise<void> | void;
-/**
-* Release a permit.
-*
-* @example
-* semaphore.release(sem);
-*/
-export declare const release: (sem: Extend<Semaphore>) => void;
-export {};

package/semaphore.js

@@ -1 +0,0 @@
-import{loadedResolve,loadResolve}from"./utils.js";let push=(qu,item)=>{let tail=qu[3];qu[3]=tail+1===qu[1]?0:tail+1;qu[0][tail]=item};export let full=qu=>qu[2]===qu[3]&&qu[0][qu[2]]!==null;let pop=qu=>{let head=qu[2];qu[2]=head+1===qu[1]?0:head+1;let val=qu[0][head];qu[0][head]=null;return val};export let init=(permits,capacity)=>[new Array(capacity).fill(null),capacity,0,0,permits];export let acquire=sem=>{if(--sem[4]<0){let promise=new Promise(loadResolve);push(sem,loadedResolve);return promise}};export let release=sem=>{sem[4]++<0&&pop(sem)()};

package/signal.d.ts

@@ -1,41 +0,0 @@
-/**
-* Describe a signal
-*/
-export type Signal = [interrupted: boolean, ...parents: Signal[]];
-/**
-* Create a signal
-*/
-export declare const init: () => Signal;
-/**
-* Create a signal that aborts when any of the input signals abort
-* @param sigs
-*/
-export declare const any: (signals: Signal[]) => Signal;
-/**
-* Create a signal that when interrupted will interrupt a group of other signals
-*/
-export declare const group: (signals: Signal[]) => Signal;
-/**
-* Check whether the signal has been aborted
-* @param t
-*/
-export declare const aborted: (t: Signal) => boolean;
-/**
-* Abort a signal
-* @param t
-*/
-export declare const abort: (t: Signal) => void;
-/**
-* Abort a signal after a duration
-* @param t
-*/
-export declare const abortAfter: (ms: number, t: Signal) => void;
-/**
-* Create a signal that aborts after ms
-* @param ms
-*/
-export declare const timeout: (ms: number) => Signal;
-/**
-* Attach a signal to a `DisposableStack` or `AsyncDisposableStack`
-*/
-export declare const adopt: (t: Signal, stack: DisposableStack | AsyncDisposableStack) => void;

package/signal.js

@@ -1 +0,0 @@
-export let init=()=>[false];export let any=signals=>{let sig=[false];for(let i=0;i<signals.length;i++)signals[i].push(sig);return sig};let _=[false];export let group=signals=>_.concat(signals);export let aborted=t=>t[0];export let abort=t=>{if(!t[0]){t[0]=true;if(t.length>1)for(let i=1;i<t.length;i++)abort(t[i])}};export let abortAfter=(ms,t)=>{setTimeout(()=>abort(t),ms)};export let timeout=ms=>{let sig=[false];abortAfter(ms,sig);return sig};export let adopt=(t,stack)=>{stack.adopt(t,abort)};