@fncts/io 0.0.17 → 0.0.19

package/_src/Reloadable/definition.ts

@@ -0,0 +1,34 @@
+import { IterableWeakMap } from "@fncts/base/collection/weak/IterableWeakMap";
+
+/**
+ * @tsplus type fncts.io.Reloadable
+ * @tsplus companion fncts.io.ReloadableOps
+ */
+export class Reloadable<Service> {
+  declare _Service: (_: never) => Service;
+  constructor(readonly scopedRef: ScopedRef<Service>, readonly reload: IO<never, unknown, void>) {}
+
+  get get(): UIO<Service> {
+    return this.scopedRef.get;
+  }
+
+  get reloadFork(): UIO<void> {
+    return this.reload.forkDaemon.asUnit;
+  }
+}
+
+const tagMap: IterableWeakMap<Tag<any>, Tag<any>> = new IterableWeakMap();
+
+/**
+ * @tsplus derive fncts.Tag[fncts.io.Reloadable]<_> 10
+ */
+export function deriveTag<S>(
+  ...[tag]: [S] extends [Reloadable<infer X>] ? [tag: Tag<X>] : [tag: Tag<S>]
+): Tag<Reloadable<S>> {
+  if (tagMap.has(tag)) {
+    return tagMap.get(tag) as Tag<Reloadable<S>>;
+  }
+  const reloadableTag = Tag<Reloadable<S>>(`Reloadable(${tag.id})`);
+  tagMap.set(tag, reloadableTag);
+  return reloadableTag;
+}

package/_src/Reloadable.ts

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

package/_src/internal/IsFatal.ts

@@ -0,0 +1,79 @@
+export const enum IsFatalTag {
+  Single,
+  Empty,
+  Both,
+}
+
+export const IsFatalTypeId = Symbol.for("fncts.io.IsFatal");
+export type IsFatalTypeId = typeof IsFatalTypeId;
+
+/**
+ * @tsplus type fncts.io.IsFatal
+ * @tsplus companion fncts.io.IsFatalOps
+ */
+export abstract class IsFatal {
+  readonly _typeId: IsFatalTypeId = IsFatalTypeId;
+
+  apply(t: unknown): boolean {
+    concrete(this);
+    switch (this._tag) {
+      case IsFatalTag.Single:
+        return this.predicate(t);
+      case IsFatalTag.Empty:
+        return false;
+      case IsFatalTag.Both:
+        return this.left.apply(t) || this.right.apply(t);
+    }
+  }
+}
+
+export class Single extends IsFatal {
+  readonly _tag = IsFatalTag.Single;
+  constructor(readonly predicate: Predicate<unknown>) {
+    super();
+  }
+}
+
+export class Empty extends IsFatal {
+  readonly _tag = IsFatalTag.Empty;
+}
+
+export class Both extends IsFatal {
+  readonly _tag = IsFatalTag.Both;
+  constructor(readonly left: IsFatal, readonly right: IsFatal) {
+    super();
+  }
+}
+
+function concrete(u: IsFatal): asserts u is Single | Empty | Both {
+  //
+}
+
+/**
+ * @tsplus static fncts.io.IsFatalOps empty
+ */
+export const empty: IsFatal = new Empty();
+
+/**
+ * @tsplus static fncts.io.IsFatalOps __call
+ */
+export function makeIsFatal(predicate: Predicate<unknown>): IsFatal {
+  return new Single(predicate);
+}
+
+/**
+ * @tsplus static fncts.io.IsFatalOps both
+ * @tsplus fluent fncts.io.IsFatal both
+ * @tsplus operator fncts.io.IsFatal |
+ */
+export function both(left: IsFatal, right: IsFatal): IsFatal {
+  concrete(left);
+  concrete(right);
+  if (left._tag === IsFatalTag.Empty) {
+    return right;
+  }
+  if (right._tag === IsFatalTag.Empty) {
+    return left;
+  }
+  return new Both(left, right);
+}

package/internal/IsFatal.d.ts

@@ -0,0 +1,47 @@
+import { Predicate } from "@fncts/base/data/Predicate/definition";
+export declare const enum IsFatalTag {
+    Single = 0,
+    Empty = 1,
+    Both = 2
+}
+export declare const IsFatalTypeId: unique symbol;
+export type IsFatalTypeId = typeof IsFatalTypeId;
+/**
+ * @tsplus type fncts.io.IsFatal
+ * @tsplus companion fncts.io.IsFatalOps
+ */
+export declare abstract class IsFatal {
+    readonly _typeId: IsFatalTypeId;
+    apply(t: unknown): boolean;
+}
+export declare class Single extends IsFatal {
+    readonly predicate: Predicate<unknown>;
+    readonly _tag = IsFatalTag.Single;
+    constructor(predicate: Predicate<unknown>);
+}
+export declare class Empty extends IsFatal {
+    readonly _tag = IsFatalTag.Empty;
+}
+export declare class Both extends IsFatal {
+    readonly left: IsFatal;
+    readonly right: IsFatal;
+    readonly _tag = IsFatalTag.Both;
+    constructor(left: IsFatal, right: IsFatal);
+}
+/**
+ * @tsplus static fncts.io.IsFatalOps empty
+ * @tsplus location "@fncts/io/internal/IsFatal"
+ */
+export declare const empty: IsFatal;
+/**
+ * @tsplus static fncts.io.IsFatalOps __call
+ * @tsplus location "@fncts/io/internal/IsFatal"
+ */
+export declare function makeIsFatal(predicate: Predicate<unknown>): IsFatal;
+/**
+ * @tsplus static fncts.io.IsFatalOps both
+ * @tsplus fluent fncts.io.IsFatal both
+ * @tsplus operator fncts.io.IsFatal |
+ * @tsplus location "@fncts/io/internal/IsFatal"
+ */
+export declare function both(left: IsFatal, right: IsFatal): IsFatal;

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@fncts/io",
-  "version": "0.0.17",
+  "version": "0.0.19",
   "dependencies": {
-    "@fncts/base": "0.0.17",
-    "@fncts/transformers": "0.0.1",
-    "@fncts/typelevel": "0.0.13"
+    "@fncts/base": "0.0.19",
+    "@fncts/transformers": "0.0.2",
+    "@fncts/typelevel": "0.0.14"
   },
   "exports": {
     "./*": {