@volynets/reflex 0.1.1 → 0.1.3

package/src/policy/scheduler/scheduler.queue.ts

@@ -0,0 +1,74 @@
+import type { WatcherQueue, EffectNode } from "./scheduler.types";
+
+const INITIAL_QUEUE_CAPACITY = 16;
+
+function growWatcherQueue(queue: WatcherQueue): void {
+  const ring = queue.ring;
+  const capacity = ring.length;
+  if (capacity === 0) {
+    ring.length = INITIAL_QUEUE_CAPACITY;
+    return;
+  }
+
+  const size = queue.size;
+  const head = queue.head;
+  const mask = capacity - 1;
+  const nextCapacity = capacity << 1;
+  const next = new Array<EffectNode>(nextCapacity);
+
+  for (let i = 0; i < size; ++i) {
+    next[i] = ring[(head + i) & mask]!;
+  }
+
+  ring.length = nextCapacity;
+  for (let i = 0; i < size; ++i) {
+    ring[i] = next[i]!;
+  }
+
+  queue.head = 0;
+  queue.tail = size;
+}
+
+function pushWatcherQueue(this: WatcherQueue, node: EffectNode): void {
+  const ring = this.ring;
+  if (this.size === ring.length) {
+    growWatcherQueue(this);
+  }
+
+  const tail = this.tail;
+  ring[tail] = node;
+  this.tail = (tail + 1) & (ring.length - 1);
+  ++this.size;
+}
+
+function shiftWatcherQueue(this: WatcherQueue): EffectNode | null {
+  if (this.size === 0) {
+    return null;
+  }
+
+  const ring = this.ring;
+  const head = this.head;
+  const node = ring[head]!;
+  ring[head] = undefined as never;
+  this.head = (head + 1) & (ring.length - 1);
+  --this.size;
+  return node;
+}
+
+function clearWatcherQueue(this: WatcherQueue): void {
+  this.head = 0;
+  this.tail = 0;
+  this.size = 0;
+}
+
+export function createWatcherQueue(): WatcherQueue {
+  return {
+    ring: [],
+    head: 0,
+    tail: 0,
+    size: 0,
+    push: pushWatcherQueue,
+    shift: shiftWatcherQueue,
+    clear: clearWatcherQueue,
+  };
+}

package/src/policy/scheduler/scheduler.types.ts

@@ -0,0 +1,54 @@
+import type { ExecutionContext, ReactiveNode } from "@reflex/runtime";
+import type {
+  EffectSchedulerMode,
+  SchedulerPhase,
+} from "./scheduler.constants";
+
+export type EffectNode = ReactiveNode<undefined | Destructor>;
+
+export interface WatcherQueue {
+  readonly ring: EffectNode[];
+  head: number;
+  tail: number;
+  size: number;
+
+  push(node: EffectNode): void;
+  shift(): EffectNode | null;
+  clear(): void;
+}
+
+export function noopNotifySettled(): void {}
+
+export interface SchedulerCore {
+  readonly queue: WatcherQueue;
+  flush(): void;
+  enterBatch(): void;
+  leaveBatch(): boolean;
+  reset(): void;
+
+  get batchDepth(): number;
+  get phase(): SchedulerPhase;
+}
+
+export interface EffectScheduler {
+  readonly ring: EffectNode[];
+  readonly mode: EffectSchedulerMode;
+  readonly context: ExecutionContext;
+  readonly runtimeNotifySettled: (() => void) | undefined;
+
+  enqueue(node: ReactiveNode): void;
+  batch<T>(fn: () => T): T;
+  flush(): void;
+  notifySettled(): void;
+  reset(): void;
+
+  get head(): number;
+  get batchDepth(): number;
+  get phase(): SchedulerPhase;
+}
+
+export type SchedulerBatch = EffectScheduler["batch"];
+export type SchedulerEnqueue = EffectScheduler["enqueue"];
+export type SchedulerNotifySettled = EffectScheduler["notifySettled"];
+export type SchedulerRuntimeNotifySettled =
+  EffectScheduler["runtimeNotifySettled"];

package/src/policy/scheduler/variants/index.ts

@@ -0,0 +1,3 @@
+export * from "./scheduler.eager";
+export * from "./scheduler.flush";
+export * from "./scheduler.sab";

package/src/policy/scheduler/variants/scheduler.eager.ts

@@ -0,0 +1,46 @@
+import type { ExecutionContext } from "@reflex/runtime";
+import { EffectSchedulerMode } from "../scheduler.constants";
+import {
+  createSchedulerCore,
+  isRuntimeInactive,
+  createSchedulerInstance,
+  tryEnqueue,
+} from "../scheduler.core";
+import type { EffectNode, EffectScheduler } from "../scheduler.types";
+
+export function createEagerScheduler(
+  context: ExecutionContext,
+): EffectScheduler {
+  const core = createSchedulerCore();
+  const queue = core.queue;
+  const notifySettled = (): void => {
+    if (isRuntimeInactive(context, core) && queue.size !== 0) {
+      core.flush();
+    }
+  };
+  const enqueueToQueue = tryEnqueue.bind(null, queue);
+  const enqueue = (node: EffectNode) => {
+    if (!enqueueToQueue(node)) return;
+    if (isRuntimeInactive(context, core)) core.flush();
+  };
+  const batch = <T>(fn: () => T): T => {
+    core.enterBatch();
+    try {
+      return fn();
+    } finally {
+      if (core.leaveBatch() && queue.size !== 0) {
+        core.flush();
+      }
+    }
+  };
+
+  return createSchedulerInstance(
+    EffectSchedulerMode.Eager,
+    context,
+    core,
+    enqueue,
+    batch,
+    notifySettled,
+    notifySettled,
+  );
+}

package/src/policy/scheduler/variants/scheduler.flush.ts

@@ -0,0 +1,35 @@
+import type { ExecutionContext } from "@reflex/runtime";
+import { EffectSchedulerMode } from "../scheduler.constants";
+import {
+  createSchedulerCore,
+  createSchedulerInstance,
+  tryEnqueue,
+} from "../scheduler.core";
+import type { EffectScheduler } from "../scheduler.types";
+import { noopNotifySettled } from "../scheduler.types";
+
+export function createFlushScheduler(
+  context: ExecutionContext,
+): EffectScheduler {
+  const core = createSchedulerCore();
+  const queue = core.queue;
+  const enqueue = tryEnqueue.bind(null, queue);
+  const batch = <T>(fn: () => T): T => {
+    core.enterBatch();
+    try {
+      return fn();
+    } finally {
+      core.leaveBatch();
+    }
+  };
+  
+  return createSchedulerInstance(
+    EffectSchedulerMode.Flush,
+    context,
+    core,
+    enqueue,
+    batch,
+    noopNotifySettled,
+    undefined,
+  );
+}

package/src/policy/scheduler/variants/scheduler.sab.ts

@@ -0,0 +1,37 @@
+import type { ExecutionContext } from "@reflex/runtime";
+import { EffectSchedulerMode } from "../scheduler.constants";
+import {
+  createSchedulerCore,
+  createSchedulerInstance,
+  isContextSettled,
+  tryEnqueue,
+} from "../scheduler.core";
+import type { EffectScheduler } from "../scheduler.types";
+import { noopNotifySettled } from "../scheduler.types";
+
+export function createSabScheduler(context: ExecutionContext): EffectScheduler {
+  const core = createSchedulerCore();
+  const queue = core.queue;
+  const enqueue = tryEnqueue.bind(null, queue);
+
+  const batch = <T>(fn: () => T): T => {
+    core.enterBatch();
+    try {
+      return fn();
+    } finally {
+      if (core.leaveBatch() && queue.size !== 0 && isContextSettled(context)) {
+        core.flush();
+      }
+    }
+  };
+
+  return createSchedulerInstance(
+    EffectSchedulerMode.SAB,
+    context,
+    core,
+    enqueue,
+    batch,
+    noopNotifySettled,
+    undefined,
+  );
+}

package/src/unstable/index.ts

@@ -0,0 +1,4 @@
+// eslint-disable-next-line @typescript-eslint/triple-slash-reference
+/// <reference path="../globals.d.ts" />
+
+export * from "./resource";