@routinejs/core 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Jason Nall
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/index.d.cts

@@ -0,0 +1,73 @@
+export declare type AllowedYield<Defs extends EventDefs> = typeof INDEFINITELY | EventReq<EventUnion<Defs>>;
+
+export declare class ChildScope implements Disposable {
+    #private;
+    disposed: boolean;
+    constructor(make: () => RoutineGen, runner?: Runner);
+    resume(value?: any): void;
+    [Symbol.dispose](): void;
+}
+
+export declare function defaultRunner(): Runner;
+
+/** Create a RoutineEmitter from a subscribe function. */
+export declare function emitter<T>(subscribe: (cb: (ev: T) => void) => Disposable): RoutineEmitter<T>;
+
+declare const EVENT_REQ: unique symbol;
+
+export declare type EventDefs = Record<string, RoutineEmitter<any>>;
+
+declare type EventPayload<E> = E extends RoutineEmitter<infer T> ? T : never;
+
+/** Yield token: "wait for one event of type T" */
+export declare type EventReq<T> = {
+    readonly [EVENT_REQ]: T;
+};
+
+export declare type EventRoutine<T extends RoutineNode, Defs extends EventDefs> = {
+    run(root: T): void;
+};
+
+export declare function eventRoutine<T extends RoutineNode, Defs extends EventDefs>(defs: Defs, make: (opts: unknown, ctx: Defs & {
+    root: T;
+}) => Generator<AllowedYield<Defs>, void, any>): EventRoutine<T, Defs>;
+
+declare type EventUnion<Defs extends EventDefs> = EventPayload<Defs[keyof Defs]>;
+
+export declare const INDEFINITELY: unique symbol;
+
+export declare function isDisposable(x: any): x is Disposable;
+
+export declare type Routine<T extends RoutineNode> = {
+    run(root: T): void;
+};
+
+export declare function routine<T extends RoutineNode>(make: (root: T) => Generator<any, void, any>): Routine<T>;
+
+/** Routine event emitter (runtime subscribes, resumes generator on first event) */
+export declare type RoutineEmitter<T> = {
+    _subscribe(cb: (ev: T) => void): Disposable;
+};
+
+/** A routine generator. */
+export declare type RoutineGen = Generator<Yieldable, void, any>;
+
+export declare abstract class RoutineNode implements Disposable {
+    #private;
+    own<T extends Disposable | AsyncDisposable | null | undefined>(d: T): T;
+    child(make: () => RoutineGen): ChildScope;
+    [Symbol.dispose](): void;
+}
+
+export declare interface Runner {
+    attach(gen: RoutineGen): void;
+    step(gen: RoutineGen, resumeValue?: any): void;
+    disposeGen(gen: RoutineGen): void;
+}
+
+/** Create a typed request token; yield this to receive a single event payload. */
+export declare function waitFor<T>(e: RoutineEmitter<T>): EventReq<T>;
+
+export declare type Yieldable = typeof INDEFINITELY | EventReq<any>;
+
+export { }

package/dist/index.d.ts

@@ -0,0 +1,73 @@
+export declare type AllowedYield<Defs extends EventDefs> = typeof INDEFINITELY | EventReq<EventUnion<Defs>>;
+
+export declare class ChildScope implements Disposable {
+    #private;
+    disposed: boolean;
+    constructor(make: () => RoutineGen, runner?: Runner);
+    resume(value?: any): void;
+    [Symbol.dispose](): void;
+}
+
+export declare function defaultRunner(): Runner;
+
+/** Create a RoutineEmitter from a subscribe function. */
+export declare function emitter<T>(subscribe: (cb: (ev: T) => void) => Disposable): RoutineEmitter<T>;
+
+declare const EVENT_REQ: unique symbol;
+
+export declare type EventDefs = Record<string, RoutineEmitter<any>>;
+
+declare type EventPayload<E> = E extends RoutineEmitter<infer T> ? T : never;
+
+/** Yield token: "wait for one event of type T" */
+export declare type EventReq<T> = {
+    readonly [EVENT_REQ]: T;
+};
+
+export declare type EventRoutine<T extends RoutineNode, Defs extends EventDefs> = {
+    run(root: T): void;
+};
+
+export declare function eventRoutine<T extends RoutineNode, Defs extends EventDefs>(defs: Defs, make: (opts: unknown, ctx: Defs & {
+    root: T;
+}) => Generator<AllowedYield<Defs>, void, any>): EventRoutine<T, Defs>;
+
+declare type EventUnion<Defs extends EventDefs> = EventPayload<Defs[keyof Defs]>;
+
+export declare const INDEFINITELY: unique symbol;
+
+export declare function isDisposable(x: any): x is Disposable;
+
+export declare type Routine<T extends RoutineNode> = {
+    run(root: T): void;
+};
+
+export declare function routine<T extends RoutineNode>(make: (root: T) => Generator<any, void, any>): Routine<T>;
+
+/** Routine event emitter (runtime subscribes, resumes generator on first event) */
+export declare type RoutineEmitter<T> = {
+    _subscribe(cb: (ev: T) => void): Disposable;
+};
+
+/** A routine generator. */
+export declare type RoutineGen = Generator<Yieldable, void, any>;
+
+export declare abstract class RoutineNode implements Disposable {
+    #private;
+    own<T extends Disposable | AsyncDisposable | null | undefined>(d: T): T;
+    child(make: () => RoutineGen): ChildScope;
+    [Symbol.dispose](): void;
+}
+
+export declare interface Runner {
+    attach(gen: RoutineGen): void;
+    step(gen: RoutineGen, resumeValue?: any): void;
+    disposeGen(gen: RoutineGen): void;
+}
+
+/** Create a typed request token; yield this to receive a single event payload. */
+export declare function waitFor<T>(e: RoutineEmitter<T>): EventReq<T>;
+
+export declare type Yieldable = typeof INDEFINITELY | EventReq<any>;
+
+export { }

package/dist/routinejs-core.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const p=Symbol("INDEFINITELY");function w(e){return{_subscribe:e}}function m(e){return e}function f(){const e=new WeakMap;function t(s){let n=e.get(s);return n||(n={stack:new DisposableStack,parked:!1},e.set(s,n)),n}function i(s){s.waiting=void 0}const o={attach(s){t(s)},step(s,n){const r=t(s);if(r.parked)return;i(r);let c;try{c=s.next(n)}catch(u){throw o.disposeGen(s),u}if(c.done){o.disposeGen(s);return}const d=c.value;if(d===p){r.parked=!0;return}const a=d;if(a&&typeof a._subscribe=="function"){let u=!0;const l=a._subscribe(y=>{if(u){u=!1;try{l[Symbol.dispose]()}catch{}o.step(s,y)}});r.waiting={unsub:l,active:!0},r.stack.use(l);return}throw new Error("Invalid yield: only INDEFINITELY or EventReq<T> are allowed.")},disposeGen(s){const n=e.get(s);if(n){e.delete(s);try{s.return?.()}catch{}try{n.stack.dispose()}catch{}}}};return o}class h{#t;#e;disposed=!1;constructor(t,i){this.#t=i??f(),this.#e=t(),this.#t.attach(this.#e),this.#t.step(this.#e)}resume(t){this.disposed||this.#t.step(this.#e,t)}[Symbol.dispose](){this.disposed||(this.disposed=!0,this.#t.disposeGen(this.#e))}}function b(e){return e&&typeof e=="object"&&typeof e[Symbol.dispose]=="function"}class I{#t=new DisposableStack;own(t){if(!t)return t;if(b(t))this.#t.use(t);else{const i=t;this.#t.use({[Symbol.dispose](){i[Symbol.asyncDispose]()}})}return t}child(t){const i=new h(t);return this.own(i),i}[Symbol.dispose](){this.#t.dispose()}}function S(e){return{run(t){t.child(()=>e(t))}}}function v(e,t){return{run(i){i.child(()=>t(void 0,{...e,root:i}))}}}exports.ChildScope=h;exports.INDEFINITELY=p;exports.RoutineNode=I;exports.defaultRunner=f;exports.emitter=w;exports.eventRoutine=v;exports.isDisposable=b;exports.routine=S;exports.waitFor=m;

package/dist/routinejs-core.js

@@ -0,0 +1,142 @@
+const h = /* @__PURE__ */ Symbol("INDEFINITELY");
+function w(e) {
+  return { _subscribe: e };
+}
+function m(e) {
+  return e;
+}
+function f() {
+  const e = /* @__PURE__ */ new WeakMap();
+  function t(s) {
+    let n = e.get(s);
+    return n || (n = { stack: new DisposableStack(), parked: !1 }, e.set(s, n)), n;
+  }
+  function i(s) {
+    s.waiting = void 0;
+  }
+  const o = {
+    attach(s) {
+      t(s);
+    },
+    step(s, n) {
+      const r = t(s);
+      if (r.parked) return;
+      i(r);
+      let u;
+      try {
+        u = s.next(n);
+      } catch (c) {
+        throw o.disposeGen(s), c;
+      }
+      if (u.done) {
+        o.disposeGen(s);
+        return;
+      }
+      const l = u.value;
+      if (l === h) {
+        r.parked = !0;
+        return;
+      }
+      const a = l;
+      if (a && typeof a._subscribe == "function") {
+        let c = !0;
+        const p = a._subscribe((d) => {
+          if (c) {
+            c = !1;
+            try {
+              p[Symbol.dispose]();
+            } catch {
+            }
+            o.step(s, d);
+          }
+        });
+        r.waiting = { unsub: p, active: !0 }, r.stack.use(p);
+        return;
+      }
+      throw new Error(
+        "Invalid yield: only INDEFINITELY or EventReq<T> are allowed."
+      );
+    },
+    disposeGen(s) {
+      const n = e.get(s);
+      if (n) {
+        e.delete(s);
+        try {
+          s.return?.();
+        } catch {
+        }
+        try {
+          n.stack.dispose();
+        } catch {
+        }
+      }
+    }
+  };
+  return o;
+}
+class y {
+  #t;
+  #e;
+  disposed = !1;
+  constructor(t, i) {
+    this.#t = i ?? f(), this.#e = t(), this.#t.attach(this.#e), this.#t.step(this.#e);
+  }
+  resume(t) {
+    this.disposed || this.#t.step(this.#e, t);
+  }
+  [Symbol.dispose]() {
+    this.disposed || (this.disposed = !0, this.#t.disposeGen(this.#e));
+  }
+}
+function b(e) {
+  return e && typeof e == "object" && typeof e[Symbol.dispose] == "function";
+}
+class k {
+  #t = new DisposableStack();
+  own(t) {
+    if (!t) return t;
+    if (b(t))
+      this.#t.use(t);
+    else {
+      const i = t;
+      this.#t.use({
+        [Symbol.dispose]() {
+          i[Symbol.asyncDispose]();
+        }
+      });
+    }
+    return t;
+  }
+  child(t) {
+    const i = new y(t);
+    return this.own(i), i;
+  }
+  [Symbol.dispose]() {
+    this.#t.dispose();
+  }
+}
+function I(e) {
+  return {
+    run(t) {
+      t.child(() => e(t));
+    }
+  };
+}
+function S(e, t) {
+  return {
+    run(i) {
+      i.child(() => t(void 0, { ...e, root: i }));
+    }
+  };
+}
+export {
+  y as ChildScope,
+  h as INDEFINITELY,
+  k as RoutineNode,
+  f as defaultRunner,
+  w as emitter,
+  S as eventRoutine,
+  b as isDisposable,
+  I as routine,
+  m as waitFor
+};

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@routinejs/core",
+  "version": "0.0.1",
+  "description": "Express ownership graphs and control flow together, with automatic resource management.",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/jsonnull/routinejs",
+    "directory": "packages/core"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "type": "module",
+  "files": [
+    "dist"
+  ],
+  "main": "./dist/routinejs-core.cjs",
+  "module": "./dist/routinejs-core.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/routinejs-core.js"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/routinejs-core.cjs"
+      }
+    }
+  },
+  "devDependencies": {
+    "typescript": "^5.9.3",
+    "vite": "^7.3.1",
+    "vite-plugin-dts": "^4.5.4",
+    "vitest": "^4.0.18"
+  },
+  "scripts": {
+    "build": "vite build",
+    "dev": "vite build --watch",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:typecheck": "vitest --typecheck.only --typecheck.include='tests/**/*.test-d.ts' --run"
+  }
+}