WIP

Author: CMCDragonkai

package-lock.json

@@ -25,6 +25,7 @@
     "@matrixai/async-cancellable": "^1.1.1",
     "@matrixai/async-locks": "^4.0.0",
     "@matrixai/errors": "^1.1.7",
+    "@matrixai/resources": "^1.1.5",
     "@matrixai/timer": "^1.1.1"
   },
   "devDependencies": {

package.json

@@ -0,0 +1,28 @@
+
+// IF you have a `@monitored`
+// That means you have `@timedCancellable` at thes ame time
+// You can do `@timed` `@cancellable`
+// But instead `@timedCancellable` combines them all
+// SO @monitored does it too
+// Cause if you can lock things... you can also use the timer and monitor
+// Due to the usageo f the locking ctx
+// await ctx.monitor.lock(...)
+// someotherfunction(ctx)
+// it passes the monitor down there
+// Well the problem is that whe nyou do it
+// you'd need to have the timer monitor applied?
+// you don'tn eed to apply the ctx
+// the ctx is automtaically applied( so the function ctx of timer and signal)
+// isautomatically applied to all LOCKS
+// when you do this you also need to use the ability to create a monitor
+// obj.withMonitor(async (monitor) => {
+// })
+
+// I wnat to see to quickly prototyep what this will look like
+
+
+function monitored() {
+
+}
+
+export default monitored;

src/decorators/monitored.ts

@@ -1,4 +1,7 @@
+import type { ResourceAcquire } from '@matrixai/resources';
+import type { PromiseCancellableController } from '@matrixai/async-cancellable';
 import { Timer } from '@matrixai/timer';
+import { Monitor, LockBox, RWLockReader, RWLockWriter } from '@matrixai/async-locks';
 
 const AsyncFunction = (async () => {}).constructor;
 const GeneratorFunction = function* () {}.constructor;
@@ -59,6 +62,63 @@ function checkContextTimed(
   }
 }
 
+/**
+ * Timer resource
+ * Use it with `withF` or `withG`.
+ */
+function timer<T = void>(
+  handlerOrOpts?:
+    | ((signal: AbortSignal) => T | PromiseLike<T>)
+    | {
+        handler?: (signal: AbortSignal) => T | PromiseLike<T>;
+        delay?: number;
+        lazy?: boolean;
+        controller?: PromiseCancellableController;
+      },
+  delay: number = 0,
+  lazy: boolean = false,
+  controller?: PromiseCancellableController,
+): ResourceAcquire<Timer<T>> {
+  return async () => {
+    let timer: Timer<T>;
+    if (typeof handlerOrOpts === 'function') {
+      timer = new Timer(handlerOrOpts, delay, lazy, controller);
+    } else {
+      timer = new Timer(handlerOrOpts);
+    }
+    return [
+      async () => {
+        timer.cancel();
+      },
+      timer
+    ];
+  };
+}
+
+/**
+ * Monitor resource.
+ * Use it with `withF` or `withG`.
+ */
+function monitor<RWLock extends RWLockReader | RWLockWriter>(
+  lockBox: LockBox<RWLock>,
+  lockConstructor: new () => RWLock,
+  locksPending?: Map<string, { count: number }>,
+): ResourceAcquire<Monitor<RWLock>> {
+  return async () => {
+    const monitor = new Monitor<RWLock>(
+      lockBox,
+      lockConstructor,
+      locksPending
+    );
+    return [
+      async () => {
+        await monitor.unlockAll();
+      },
+      monitor
+    ];
+  };
+}
+
 function isPromiseLike(v: any): v is PromiseLike<unknown> {
   return v != null && typeof v.then === 'function';
 }
@@ -100,6 +160,8 @@ export {
   getContextIndex,
   checkContextCancellable,
   checkContextTimed,
+  timer,
+  monitor,
   isPromiseLike,
   isGenerator,
   isAsyncGenerator,