@graffy/core 0.15.25-alpha.1 → 0.15.25-alpha.2

package/index.cjs

@@ -1,11 +1,9 @@
 "use strict";
-var common = require("@graffy/common");
-var stream = require("@graffy/stream");
-var debug = require("debug");
-function _interopDefaultLegacy(e) {
-  return e && typeof e === "object" && "default" in e ? e : { "default": e };
-}
-var debug__default = /* @__PURE__ */ _interopDefaultLegacy(debug);
+const common = require("@graffy/common");
+const stream = require("@graffy/stream");
+const debug = require("debug");
+const _interopDefaultLegacy = (e) => e && typeof e === "object" && "default" in e ? e : { default: e };
+const debug__default = /* @__PURE__ */ _interopDefaultLegacy(debug);
 function isPlainObject(obj) {
   return obj && typeof obj === "object" && !Array.isArray(obj);
 }
@@ -113,7 +111,7 @@ function shiftGen(fn, path) {
     yield* remainingNextStream ? common.mergeStreams(resultStream, remainingNextStream) : resultStream;
   };
 }
-const log = debug__default["default"]("graffy:core");
+const log = debug__default.default("graffy:core");
 function resolve(handlers, firstPayload, firstOptions) {
   if (!handlers || !handlers.length)
     throw Error("resolve.no_provider");
@@ -163,40 +161,52 @@ class Graffy {
   onRead(...args) {
     const [pathArg, handle] = validateOn(...args);
     const path = this.path.concat(pathArg);
-    this.core.on("read", path, shiftFn(async function porcelainRead(query, options) {
-      const decoded = common.decodeQuery(query);
-      const encoded = common.encodeGraph(await handle(decoded, options));
-      const finalized = common.finalize(encoded, query);
-      return finalized;
-    }, path));
+    this.core.on(
+      "read",
+      path,
+      shiftFn(async function porcelainRead(query, options) {
+        const decoded = common.decodeQuery(query);
+        const encoded = common.encodeGraph(await handle(decoded, options));
+        const finalized = common.finalize(encoded, query);
+        return finalized;
+      }, path)
+    );
   }
   onWatch(...args) {
     const [pathArg, handle] = validateOn(...args);
     const path = this.path.concat(pathArg);
-    this.core.on("watch", path, shiftGen(function porcelainWatch(query, options) {
-      return stream.makeStream((push, end) => {
-        const subscription = handle(common.decodeQuery(query), options);
-        (async function() {
-          try {
-            let firstValue = (await subscription.next()).value;
-            push(firstValue && common.finalize(common.encodeGraph(firstValue), query));
-            for await (const value of subscription) {
-              push(value && common.encodeGraph(value));
+    this.core.on(
+      "watch",
+      path,
+      shiftGen(function porcelainWatch(query, options) {
+        return stream.makeStream((push, end) => {
+          const subscription = handle(common.decodeQuery(query), options);
+          (async function() {
+            try {
+              let firstValue = (await subscription.next()).value;
+              push(firstValue && common.finalize(common.encodeGraph(firstValue), query));
+              for await (const value of subscription) {
+                push(value && common.encodeGraph(value));
+              }
+            } catch (e) {
+              end(e);
             }
-          } catch (e) {
-            end(e);
-          }
-        })();
-        return () => subscription.return();
-      });
-    }, path));
+          })();
+          return () => subscription.return();
+        });
+      }, path)
+    );
   }
   onWrite(...args) {
     const [pathArg, handle] = validateOn(...args);
     const path = this.path.concat(pathArg);
-    this.core.on("write", path, shiftFn(async function porcelainWrite(change, options) {
-      return common.encodeGraph(await handle(common.decodeGraph(change), options));
-    }, path));
+    this.core.on(
+      "write",
+      path,
+      shiftFn(async function porcelainWrite(change, options) {
+        return common.encodeGraph(await handle(common.decodeGraph(change), options));
+      }, path)
+    );
   }
   use(...args) {
     const [pathArg, provider] = validateOn(...args);
@@ -218,7 +228,10 @@ class Graffy {
     const rootQuery = common.wrapObject(porcelainQuery, path);
     const query = common.encodeQuery(rootQuery);
     const stream$1 = this.core.call("watch", query, options || {});
-    return stream.mapStream(stream$1, (value) => common.unwrapObject(common.decorate(value, rootQuery), common.decodePath(path)));
+    return stream.mapStream(
+      stream$1,
+      (value) => common.unwrapObject(common.decorate(value, rootQuery), common.decodePath(path))
+    );
   }
   async write(...args) {
     const [path, porcelainChange, options] = validateCall(...args);

package/index.mjs

@@ -1,4 +1,4 @@
-import { encodePath, unwrap, remove, wrap, merge, mergeStreams, encodeGraph, decodeGraph, wrapObject, encodeQuery, unwrapObject, decorate, decodePath, decodeQuery, finalize } from "@graffy/common";
+import { encodePath, unwrap, remove, wrap, merge, mergeStreams, wrapObject, encodeQuery, unwrapObject, decorate, decodePath, encodeGraph, decodeGraph, decodeQuery, finalize } from "@graffy/common";
 import { makeStream, mapStream as mapStream$1 } from "@graffy/stream";
 import debug from "debug";
 function isPlainObject(obj) {
@@ -158,40 +158,52 @@ class Graffy {
   onRead(...args) {
     const [pathArg, handle] = validateOn(...args);
     const path = this.path.concat(pathArg);
-    this.core.on("read", path, shiftFn(async function porcelainRead(query, options) {
-      const decoded = decodeQuery(query);
-      const encoded = encodeGraph(await handle(decoded, options));
-      const finalized = finalize(encoded, query);
-      return finalized;
-    }, path));
+    this.core.on(
+      "read",
+      path,
+      shiftFn(async function porcelainRead(query, options) {
+        const decoded = decodeQuery(query);
+        const encoded = encodeGraph(await handle(decoded, options));
+        const finalized = finalize(encoded, query);
+        return finalized;
+      }, path)
+    );
   }
   onWatch(...args) {
     const [pathArg, handle] = validateOn(...args);
     const path = this.path.concat(pathArg);
-    this.core.on("watch", path, shiftGen(function porcelainWatch(query, options) {
-      return makeStream((push, end) => {
-        const subscription = handle(decodeQuery(query), options);
-        (async function() {
-          try {
-            let firstValue = (await subscription.next()).value;
-            push(firstValue && finalize(encodeGraph(firstValue), query));
-            for await (const value of subscription) {
-              push(value && encodeGraph(value));
+    this.core.on(
+      "watch",
+      path,
+      shiftGen(function porcelainWatch(query, options) {
+        return makeStream((push, end) => {
+          const subscription = handle(decodeQuery(query), options);
+          (async function() {
+            try {
+              let firstValue = (await subscription.next()).value;
+              push(firstValue && finalize(encodeGraph(firstValue), query));
+              for await (const value of subscription) {
+                push(value && encodeGraph(value));
+              }
+            } catch (e) {
+              end(e);
             }
-          } catch (e) {
-            end(e);
-          }
-        })();
-        return () => subscription.return();
-      });
-    }, path));
+          })();
+          return () => subscription.return();
+        });
+      }, path)
+    );
   }
   onWrite(...args) {
     const [pathArg, handle] = validateOn(...args);
     const path = this.path.concat(pathArg);
-    this.core.on("write", path, shiftFn(async function porcelainWrite(change, options) {
-      return encodeGraph(await handle(decodeGraph(change), options));
-    }, path));
+    this.core.on(
+      "write",
+      path,
+      shiftFn(async function porcelainWrite(change, options) {
+        return encodeGraph(await handle(decodeGraph(change), options));
+      }, path)
+    );
   }
   use(...args) {
     const [pathArg, provider] = validateOn(...args);
@@ -213,7 +225,10 @@ class Graffy {
     const rootQuery = wrapObject(porcelainQuery, path);
     const query = encodeQuery(rootQuery);
     const stream = this.core.call("watch", query, options || {});
-    return mapStream$1(stream, (value) => unwrapObject(decorate(value, rootQuery), decodePath(path)));
+    return mapStream$1(
+      stream,
+      (value) => unwrapObject(decorate(value, rootQuery), decodePath(path))
+    );
   }
   async write(...args) {
     const [path, porcelainChange, options] = validateCall(...args);
@@ -222,4 +237,6 @@ class Graffy {
     return unwrapObject(decodeGraph(writtenChange), decodePath(path));
   }
 }
-export { Graffy as default };
+export {
+  Graffy as default
+};

package/package.json

@@ -2,7 +2,7 @@
   "name": "@graffy/core",
   "description": "The main module for Graffy, a library for intuitive real-time data APIs.",
   "author": "aravind (https://github.com/aravindet)",
-  "version": "0.15.25-alpha.1",
+  "version": "0.15.25-alpha.2",
   "main": "./index.cjs",
   "exports": {
     "import": "./index.mjs",
@@ -16,8 +16,8 @@
   },
   "license": "Apache-2.0",
   "dependencies": {
-    "@graffy/common": "0.15.25-alpha.1",
-    "@graffy/stream": "0.15.25-alpha.1",
+    "@graffy/common": "0.15.25-alpha.2",
+    "@graffy/stream": "0.15.25-alpha.2",
     "debug": "^4.3.3"
   }
 }