@davidsouther/jiffies 1.0.0 → 2.0.1

package/src/fs.ts

@@ -83,7 +83,7 @@ export class FileSystem implements FileSystemAdapter {
   }
 
   private p(path: PathLike): string {
-    return path[0] == "/" ? path : join(this.cwd(), path);
+    return path[0] === "/" ? path : join(this.cwd(), path);
   }
 }
 
@@ -115,7 +115,7 @@ export class ObjectFileSystemAdapter implements FileSystemAdapter {
           const end = filename.indexOf("/", path.length + 1);
           const basename = filename.substring(
             path.length,
-            end == -1 ? undefined : end
+            end === -1 ? undefined : end
           );
           dir.push(basename);
         }
@@ -135,7 +135,7 @@ export class ObjectFileSystemAdapter implements FileSystemAdapter {
     return new Promise((resolve, reject) => {
       let file = this.fs[path];
       if (file === undefined) {
-        reject();
+        reject(new Error(`File Not Found ${path}`));
       } else {
         resolve(file);
       }
@@ -169,7 +169,7 @@ export interface Tree {
 
 export async function reset(fs: FileSystem, tree: Tree): Promise<void> {
   for (const [path, file] of Object.entries(tree)) {
-    if (typeof file == "string") {
+    if (typeof file === "string") {
       await fs.writeFile(path, file);
     } else {
       fs.cd(path);

package/src/index.html

@@ -15,15 +15,18 @@
     <div style="display: none" id="status"></div>
     <div style="display: none" id="json"></div>
     <div style="display: none" id="xml"></div>
-    <script type="module" src="./test_all.js"></script>
-    <script type="module" src="./dom/test.js"></script>
-    <script type="module" src="./components/test.js"></script>
 
     <script type="module">
-      import { execute } from "./scope/execute.js";
-      import { displayStatistics } from "./scope/display/dom.js";
-      import { onConsole } from "./scope/display/console.js";
-      import { asXML } from "./scope/display/junit.js";
+      await Promise.all([
+        import("./test_all.js"),
+        import("./dom/test.js"),
+        import("./components/test.js"),
+      ]);
+
+      import { execute } from "./scope/execute"
+      import { displayStatistics } from "./scope/display/dom"
+      import { onConsole } from "./scope/display/console"
+      import { asXML } from "./scope/display/junit"
 
       function write(id, value) {
         const start = `--- START_${id.toUpperCase()} ---`;
@@ -43,8 +46,8 @@
       })();
     </script>
     <script type="module">
-      import { nav, ul, li, strong } from "./dom/html.js";
-      import { link } from "./dom/router/link.js";
+      import { nav, ul, li, strong } from "./dom/html"
+      import { link } from "./dom/router/link"
 
       const getUrls = async () => {
         const sitemap = await fetch("/sitemap.json");

package/src/observable/_notes

@@ -1,13 +1,26 @@
-Subject
-    BehaviorSubject
-    ReplaySubject
+Subscriber
+    next(t: T)
+    error(e: E)
+    complete()
+
 Observable
-    of
-    from
-    fromEvent
-    pipe
+    ::of(...Ts)
+    ::combineLatest([...])
+    ::from(promise|Iterable|Subscribable)
+    ::fromEvent(element, eventName)
+    (subscriber) -> subscription
+    .subscribe(subscriber) -> subscription
+    .pipe(...operators) -> Observable
+
+Subject
+    -> BehaviorSubject(t)
+    -> ReplaySubject(n)
+
 operator
-    map
     filter
+    first/last
+    map
+    publishReplay
     reduce
+    takeUntil
     tap

package/src/observable/event.ts

@@ -0,0 +1,93 @@
+import { display } from "../display.js"
+import { Observable } from "./observable.js"
+
+export interface Next<T> {
+  value: T;
+  completed: false;
+  failed: false;
+}
+
+export interface Error<E> {
+  error: E;
+  completed: false;
+  failed: true;
+}
+
+export interface Completed {
+  completed: true;
+  failed: false;
+}
+
+export interface Failed {
+  completed: true;
+  failed: true;
+}
+
+export type Event<T, E> = Next<T> | Error<E> | Completed | Failed;
+
+export interface EventSubscriber<T, E> {
+  next(e: Event<T, E>): void;
+}
+
+export const next = <T>(value: T): Next<T> => ({
+  value,
+  completed: false,
+  failed: false,
+});
+export const error = <E>(e: E): Error<E> => ({
+  error: e,
+  completed: false,
+  failed: true,
+});
+export const completed = (): Completed => ({ completed: true, failed: false });
+export const failed = (): Failed => ({ completed: true, failed: true });
+
+export const isNext = <T>(event: Event<T, unknown>): event is Next<T> =>
+  !event.completed && !event.failed && event.value !== undefined;
+export const isError = <E>(event: Event<unknown, E>): event is Error<E> =>
+  event.failed && !event.completed;
+export const isCompleted = (
+  event: Event<unknown, unknown>
+): event is Completed => event.completed && !event.failed;
+export const isFailed = (event: Event<unknown, unknown>): event is Failed =>
+  event.completed && event.failed;
+
+export const isEvent = <T, E>(t: T | Event<T, E>): t is Event<T, E> => {
+  const b = t as Event<unknown, unknown>;
+  return isNext(b) || isError(b) || isCompleted(b);
+};
+
+export const asEvents = <T, E>(a: (T | Event<T, E>)[]): Event<T, E>[] =>
+  a.map((e) => (isEvent(e) ? e : next(e)));
+
+const marble = <T, E>(event: Event<T, E>): string =>
+  isError(event)
+    ? "X"
+    : isFailed(event)
+    ? "!"
+    : isCompleted(event)
+    ? "|"
+    : `(${display(event.value)})`;
+
+export const marbles = <T, E>(events: Event<T, E>[]): string =>
+  `:${events.map(marble).join("-")}`;
+
+export const collect = <T, E>(input$: Observable<T, E>) => {
+  const collected: Event<T, E>[] = [];
+
+  const subscription = input$.subscribe({
+    next: (x: T) => {
+      collected.push(next(x));
+    },
+    error: (e: E) => {
+      collected.push(error(e));
+    },
+    complete: () => {
+      collected.push(completed());
+    },
+  });
+
+  subscription.unsubscribe();
+
+  return collected;
+};

package/src/observable/observable.test.ts

@@ -0,0 +1,73 @@
+import { describe, expect, it } from "../scope/index.js"
+import { Observable, Subject, filter, map } from "./observable.js"
+
+describe("Observables", () => {
+  describe("basics", () => {
+    it("can create and observe a scalar subject", async () => {
+      const subject = new Subject<number>();
+
+      let resolved = 42;
+
+      subject.subscribe({
+        next: (n) => {
+          resolved = n;
+        },
+      });
+
+      expect(resolved).toBe(42);
+      await subject.next(64);
+      expect(resolved).toBe(64);
+    });
+  });
+
+  describe("creation", () => {
+    it("builds an observable of items", async () => {
+      const stream = Observable.of(2, 4, 8, 16);
+      let values: number[] = [];
+      await new Promise<void>((resolve) => {
+        stream.subscribe({
+          next: (n) => {
+            values.unshift(n);
+          },
+          complete: () => {
+            resolve();
+          },
+        });
+      });
+      expect(values).toEqual([16, 8, 4, 2]);
+    });
+  });
+
+  describe("pipes", () => {
+    it("runs a pipe", async () => {
+      const subject = new Subject<number>();
+
+      let resolved = 0;
+      const inflate = (i: number) => (n: number) => n + i;
+      const biggerThan = (i: number) => (n: number) => n > i;
+      const assign = (n: number) => {
+        resolved = n;
+      };
+
+      subject.pipe(map(inflate(22)), filter(biggerThan(70))).subscribe(assign);
+
+      expect(resolved).toBe(0);
+      await subject.next(42);
+      expect(resolved).toBe(0);
+      await subject.next(50);
+      expect(resolved).toBe(72);
+    });
+  });
+
+  describe("Subject", () => {
+    it("is callable", async () => {
+      const subject = new Subject<number>();
+      let resolved = 0;
+      subject.subscribe((n) => {
+        resolved = n;
+      });
+      await subject.next(42);
+      expect(resolved).toBe(42);
+    });
+  });
+});