@fncts/observable 0.0.18 → 0.0.20

package/_src/ObservableRef/definition.ts

@@ -1,57 +1,58 @@
-import type { URIO } from "@fncts/io/IO";
 import type { Observable } from "@fncts/observable/Observable";
 
-type Readable_<R, A> = Readable<R, A>;
-type Writable_<R, A> = Writable<R, A>;
+type Readable_<A> = Readable<A>;
+type Writable_<A> = Writable<A>;
 
 export declare namespace ObservableRef {
-  type Readable<R, A> = Readable_<R, A>;
-  type Writable<R, A> = Writable_<R, A>;
+  type Readable<A> = Readable_<A>;
+  type Writable<A> = Writable_<A>;
 }
 
 export class ObservableRefDescriptor<A> {
-  constructor(readonly id: symbol, readonly initial: A) {}
+  constructor(readonly initial: A) {}
 }
 
-export interface CommonObservableRef<out R> {
-  readonly _R: (_: never) => R;
-  readonly has: URIO<R, boolean>;
-  readonly delete: URIO<R, void>;
+export interface CommonObservableRef {
+  readonly unsafeClear: () => void;
+  readonly clear: UIO<void>;
 }
 
 /**
  * @tsplus type fncts.observable.ObservableRef.Readable
  */
-export interface Readable<out R, out A> extends CommonObservableRef<R> {
-  readonly _R: (_: never) => R;
+export interface Readable<out A> extends CommonObservableRef {
   readonly _Out: (_: never) => A;
-  readonly get: URIO<R, A>;
-  readonly observable: Observable<R, never, A>;
+  readonly get: UIO<A>;
+  readonly unsafeGet: () => A;
+  readonly observable: Observable<never, never, A>;
 }
 
 /**
  * @tsplus type fncts.observable.ObservableRef.Writable
  */
-export interface Writable<out R, in A> extends CommonObservableRef<R> {
-  readonly _R: (_: never) => R;
+export interface Writable<in A> extends CommonObservableRef {
   readonly _In: (_: A) => void;
-  set(a: A): URIO<R, void>;
+  set(a: A): UIO<void>;
+  unsafeSet: (a: A) => void;
 }
 
 /**
  * @tsplus type fncts.observable.ObservableRef
  * @tsplus companion fncts.observable.ObservableRefOps
  */
-export abstract class ObservableRef<out R, in A, out B> implements Readable<R, B>, Writable<R, A> {
-  declare _R: (_: never) => R;
+export abstract class ObservableRef<in A, out B> implements Readable<B>, Writable<A> {
   declare _In: (_: A) => void;
   declare _Out: (_: never) => B;
 
   constructor(readonly descriptor: ObservableRefDescriptor<any>) {}
 
-  abstract readonly get: URIO<R, B>;
-  abstract set(a: A): URIO<R, void>;
-  abstract readonly delete: URIO<R, boolean>;
-  abstract readonly has: URIO<R, boolean>;
-  abstract readonly observable: Observable<R, never, B>;
+  abstract unsafeGet(): B;
+  readonly get: UIO<B> = IO(this.unsafeGet());
+  abstract unsafeSet(a: A): void;
+  set(a: A): UIO<void> {
+    return IO(this.unsafeSet(a));
+  }
+  abstract unsafeClear(): void;
+  readonly clear = IO(this.unsafeClear());
+  abstract readonly observable: Observable<never, never, B>;
 }

package/_src/ObservableRef.ts

@@ -0,0 +1,5 @@
+// codegen:start { preset: barrel, include: ./ObservableRef/*.ts }
+export * from "./ObservableRef/api.js";
+export * from "./ObservableRef/atomic.js";
+export * from "./ObservableRef/definition.js";
+// codegen:end

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@fncts/observable",
-  "version": "0.0.18",
+  "version": "0.0.20",
   "dependencies": {
-    "@fncts/base": "0.0.29"
+    "@fncts/base": "0.0.31"
   },
   "exports": {
     "./*": {