@graffy/core 0.15.8-alpha.2 → 0.15.8

package/index.cjs

@@ -0,0 +1,231 @@
+"use strict";
+var common = require("@graffy/common");
+var stream = require("@graffy/stream");
+var debug = require("debug");
+var testing = require("@graffy/testing");
+function _interopDefaultLegacy(e) {
+  return e && typeof e === "object" && "default" in e ? e : { "default": e };
+}
+var debug__default = /* @__PURE__ */ _interopDefaultLegacy(debug);
+function isPlainObject(obj) {
+  return obj && typeof obj === "object" && !Array.isArray(obj);
+}
+function validateCall(...args) {
+  if (args.length === 1) {
+    return [[], args[0], {}];
+  } else if (args.length === 2) {
+    if (isPlainObject(args[0])) {
+      if (!isPlainObject(args[1])) {
+        throw Error(`validateCall.invalid_options: ${JSON.stringify(args[1])}`);
+      }
+      return [[], args[0], args[1]];
+    } else {
+      return [common.encodePath(args[0]), args[1], {}];
+    }
+  } else if (args.length === 3) {
+    if (!isPlainObject(args[2])) {
+      throw Error(`validateCall.invalid_options: ${JSON.stringify(args[1])}`);
+    }
+    return [common.encodePath(args[0]), args[1], args[2]];
+  }
+  throw Error(`validateCall.invalid_args: ${JSON.stringify(args)}`);
+}
+function validateOn(...args) {
+  if (args.length === 1) {
+    if (typeof args[0] !== "function") {
+      throw Error(`validateOn.invalid_handler: ${JSON.stringify(args[0])}`);
+    }
+    return [[], args[0]];
+  } else if (args.length === 2) {
+    if (typeof args[1] !== "function") {
+      throw Error(`validateOn.invalid_handler: ${JSON.stringify(args[1])}`);
+    }
+    return [common.encodePath(args[0]), args[1]];
+  }
+  throw Error(`validateOn.invalid_args: ${JSON.stringify(args)}`);
+}
+async function mapStream(stream2, fn) {
+  for await (const value of stream2) {
+    fn(value);
+  }
+}
+function shiftFn(fn, path) {
+  return async function shiftedFn(payload, options, next) {
+    let nextCalled = false;
+    let remainingNextResult;
+    const unwrappedPayload = common.unwrap(payload, path);
+    const remainingPayload = common.remove(payload, path) || [];
+    async function shiftedNext(unwrappedNextPayload) {
+      nextCalled = true;
+      const nextPayload = common.wrap(unwrappedNextPayload, path);
+      if (remainingPayload.length)
+        common.merge(nextPayload, remainingPayload);
+      const nextResult = await next(nextPayload);
+      remainingNextResult = common.remove(nextResult, path) || [];
+      return common.unwrap(nextResult, path);
+    }
+    const rawResult = await fn(unwrappedPayload, options, shiftedNext);
+    const result = common.wrap(rawResult, path);
+    if (!nextCalled && remainingPayload.length) {
+      remainingNextResult = await next(remainingPayload);
+    }
+    if (remainingNextResult && remainingNextResult.length) {
+      common.merge(result, remainingNextResult);
+    }
+    return result;
+  };
+}
+function shiftGen(fn, path) {
+  return async function* shiftedGen(payload, options, next) {
+    let nextCalled = false;
+    let remainingNextStream;
+    const unwrappedPayload = common.unwrap(payload, path);
+    const remainingPayload = common.remove(payload, path) || [];
+    const shiftedNext = async function* shiftedNextFn(unwrappedNextPayload) {
+      nextCalled = true;
+      const nextPayload = common.wrap(unwrappedNextPayload, path);
+      if (remainingPayload.length)
+        common.merge(nextPayload, remainingPayload);
+      let pushRemaining;
+      remainingNextStream = stream.makeStream((push) => {
+        pushRemaining = push;
+      });
+      for await (const value of next(nextPayload)) {
+        const unwrappedValue = common.unwrap(value, path);
+        const remainingValue = common.remove(value, path);
+        if (remainingValue)
+          pushRemaining(remainingValue);
+        if (unwrappedValue)
+          yield unwrappedValue;
+      }
+    };
+    const unwrappedStream = fn(unwrappedPayload, options, shiftedNext);
+    const firstValue = await (await unwrappedStream.next()).value;
+    const resultStream = stream.makeStream((push) => {
+      push(common.wrap(firstValue, path));
+      mapStream(unwrappedStream, (value) => {
+        push(common.wrap(value, path));
+      });
+      return () => unwrappedStream.return();
+    });
+    if (!nextCalled && remainingPayload.length) {
+      remainingNextStream = next(remainingPayload);
+    }
+    yield* remainingNextStream ? common.mergeStreams(resultStream, remainingNextStream) : resultStream;
+  };
+}
+const log = debug__default["default"]("graffy:core");
+function resolve(handlers, firstPayload, options) {
+  if (!handlers || !handlers.length)
+    throw Error("resolve.no_provider");
+  function run(i, payload) {
+    if (i >= handlers.length) {
+      throw Error("resolve.no_providers_for " + JSON.stringify(payload));
+    }
+    const { path, handle } = handlers[i];
+    if (!common.unwrap(payload, path))
+      return run(i + 1, payload);
+    let nextCalled = false;
+    return handle(payload, options, (nextPayload) => {
+      if (nextCalled) {
+        throw Error("resolve.duplicate_next_call: " + handlers[i].name);
+      }
+      if (typeof nextPayload === "undefined") {
+        throw Error("resolve.next_without_payload: " + handlers[i].name);
+      }
+      nextCalled = true;
+      return run(i + 1, nextPayload);
+    });
+  }
+  return run(0, firstPayload);
+}
+class Core {
+  constructor() {
+    this.handlers = {};
+  }
+  on(type, path, handle) {
+    this.handlers[type] = this.handlers[type] || [];
+    this.handlers[type].push({ path, handle });
+  }
+  call(type, payload, options = {}) {
+    log("call", type, testing.format(payload));
+    return resolve(this.handlers[type], payload, options);
+  }
+}
+class Graffy {
+  constructor(path = [], core = new Core()) {
+    this.core = core;
+    this.path = path;
+  }
+  on(type, ...args) {
+    const [pathArg, handler] = validateOn(...args);
+    const path = this.path.concat(pathArg);
+    this.core.on(type, path, handler);
+  }
+  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));
+  }
+  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));
+            }
+          } catch (e) {
+            end(e);
+          }
+        })();
+        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));
+  }
+  use(...args) {
+    const [path, provider] = validateOn(...args);
+    provider(new Graffy(path, this.core));
+  }
+  call(type, payload, options = {}) {
+    return this.core.call(type, payload, options);
+  }
+  async read(...args) {
+    const [path, porcelainQuery, options] = validateCall(...args);
+    const rootQuery = common.wrapObject(porcelainQuery, path);
+    const query = common.encodeQuery(rootQuery);
+    const result = await this.core.call("read", query, options || {});
+    return common.unwrapObject(common.decorate(result, rootQuery), common.decodePath(path));
+  }
+  watch(...args) {
+    const [path, porcelainQuery, options] = validateCall(...args);
+    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)));
+  }
+  async write(...args) {
+    const [path, porcelainChange, options] = validateCall(...args);
+    const change = common.wrap(common.encodeGraph(porcelainChange), path);
+    const writtenChange = await this.core.call("write", change, options || {});
+    return common.unwrapObject(common.decodeGraph(writtenChange), common.decodePath(path));
+  }
+}
+module.exports = Graffy;

package/index.mjs

@@ -0,0 +1,226 @@
+import { encodePath, unwrap, remove, wrap, merge, mergeStreams, encodeGraph, decodeGraph, wrapObject, encodeQuery, unwrapObject, decorate, decodePath, decodeQuery, finalize } from "@graffy/common";
+import { makeStream, mapStream as mapStream$1 } from "@graffy/stream";
+import debug from "debug";
+import { format } from "@graffy/testing";
+function isPlainObject(obj) {
+  return obj && typeof obj === "object" && !Array.isArray(obj);
+}
+function validateCall(...args) {
+  if (args.length === 1) {
+    return [[], args[0], {}];
+  } else if (args.length === 2) {
+    if (isPlainObject(args[0])) {
+      if (!isPlainObject(args[1])) {
+        throw Error(`validateCall.invalid_options: ${JSON.stringify(args[1])}`);
+      }
+      return [[], args[0], args[1]];
+    } else {
+      return [encodePath(args[0]), args[1], {}];
+    }
+  } else if (args.length === 3) {
+    if (!isPlainObject(args[2])) {
+      throw Error(`validateCall.invalid_options: ${JSON.stringify(args[1])}`);
+    }
+    return [encodePath(args[0]), args[1], args[2]];
+  }
+  throw Error(`validateCall.invalid_args: ${JSON.stringify(args)}`);
+}
+function validateOn(...args) {
+  if (args.length === 1) {
+    if (typeof args[0] !== "function") {
+      throw Error(`validateOn.invalid_handler: ${JSON.stringify(args[0])}`);
+    }
+    return [[], args[0]];
+  } else if (args.length === 2) {
+    if (typeof args[1] !== "function") {
+      throw Error(`validateOn.invalid_handler: ${JSON.stringify(args[1])}`);
+    }
+    return [encodePath(args[0]), args[1]];
+  }
+  throw Error(`validateOn.invalid_args: ${JSON.stringify(args)}`);
+}
+async function mapStream(stream, fn) {
+  for await (const value of stream) {
+    fn(value);
+  }
+}
+function shiftFn(fn, path) {
+  return async function shiftedFn(payload, options, next) {
+    let nextCalled = false;
+    let remainingNextResult;
+    const unwrappedPayload = unwrap(payload, path);
+    const remainingPayload = remove(payload, path) || [];
+    async function shiftedNext(unwrappedNextPayload) {
+      nextCalled = true;
+      const nextPayload = wrap(unwrappedNextPayload, path);
+      if (remainingPayload.length)
+        merge(nextPayload, remainingPayload);
+      const nextResult = await next(nextPayload);
+      remainingNextResult = remove(nextResult, path) || [];
+      return unwrap(nextResult, path);
+    }
+    const rawResult = await fn(unwrappedPayload, options, shiftedNext);
+    const result = wrap(rawResult, path);
+    if (!nextCalled && remainingPayload.length) {
+      remainingNextResult = await next(remainingPayload);
+    }
+    if (remainingNextResult && remainingNextResult.length) {
+      merge(result, remainingNextResult);
+    }
+    return result;
+  };
+}
+function shiftGen(fn, path) {
+  return async function* shiftedGen(payload, options, next) {
+    let nextCalled = false;
+    let remainingNextStream;
+    const unwrappedPayload = unwrap(payload, path);
+    const remainingPayload = remove(payload, path) || [];
+    const shiftedNext = async function* shiftedNextFn(unwrappedNextPayload) {
+      nextCalled = true;
+      const nextPayload = wrap(unwrappedNextPayload, path);
+      if (remainingPayload.length)
+        merge(nextPayload, remainingPayload);
+      let pushRemaining;
+      remainingNextStream = makeStream((push) => {
+        pushRemaining = push;
+      });
+      for await (const value of next(nextPayload)) {
+        const unwrappedValue = unwrap(value, path);
+        const remainingValue = remove(value, path);
+        if (remainingValue)
+          pushRemaining(remainingValue);
+        if (unwrappedValue)
+          yield unwrappedValue;
+      }
+    };
+    const unwrappedStream = fn(unwrappedPayload, options, shiftedNext);
+    const firstValue = await (await unwrappedStream.next()).value;
+    const resultStream = makeStream((push) => {
+      push(wrap(firstValue, path));
+      mapStream(unwrappedStream, (value) => {
+        push(wrap(value, path));
+      });
+      return () => unwrappedStream.return();
+    });
+    if (!nextCalled && remainingPayload.length) {
+      remainingNextStream = next(remainingPayload);
+    }
+    yield* remainingNextStream ? mergeStreams(resultStream, remainingNextStream) : resultStream;
+  };
+}
+const log = debug("graffy:core");
+function resolve(handlers, firstPayload, options) {
+  if (!handlers || !handlers.length)
+    throw Error("resolve.no_provider");
+  function run(i, payload) {
+    if (i >= handlers.length) {
+      throw Error("resolve.no_providers_for " + JSON.stringify(payload));
+    }
+    const { path, handle } = handlers[i];
+    if (!unwrap(payload, path))
+      return run(i + 1, payload);
+    let nextCalled = false;
+    return handle(payload, options, (nextPayload) => {
+      if (nextCalled) {
+        throw Error("resolve.duplicate_next_call: " + handlers[i].name);
+      }
+      if (typeof nextPayload === "undefined") {
+        throw Error("resolve.next_without_payload: " + handlers[i].name);
+      }
+      nextCalled = true;
+      return run(i + 1, nextPayload);
+    });
+  }
+  return run(0, firstPayload);
+}
+class Core {
+  constructor() {
+    this.handlers = {};
+  }
+  on(type, path, handle) {
+    this.handlers[type] = this.handlers[type] || [];
+    this.handlers[type].push({ path, handle });
+  }
+  call(type, payload, options = {}) {
+    log("call", type, format(payload));
+    return resolve(this.handlers[type], payload, options);
+  }
+}
+class Graffy {
+  constructor(path = [], core = new Core()) {
+    this.core = core;
+    this.path = path;
+  }
+  on(type, ...args) {
+    const [pathArg, handler] = validateOn(...args);
+    const path = this.path.concat(pathArg);
+    this.core.on(type, path, handler);
+  }
+  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));
+  }
+  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));
+            }
+          } catch (e) {
+            end(e);
+          }
+        })();
+        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));
+  }
+  use(...args) {
+    const [path, provider] = validateOn(...args);
+    provider(new Graffy(path, this.core));
+  }
+  call(type, payload, options = {}) {
+    return this.core.call(type, payload, options);
+  }
+  async read(...args) {
+    const [path, porcelainQuery, options] = validateCall(...args);
+    const rootQuery = wrapObject(porcelainQuery, path);
+    const query = encodeQuery(rootQuery);
+    const result = await this.core.call("read", query, options || {});
+    return unwrapObject(decorate(result, rootQuery), decodePath(path));
+  }
+  watch(...args) {
+    const [path, porcelainQuery, options] = validateCall(...args);
+    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)));
+  }
+  async write(...args) {
+    const [path, porcelainChange, options] = validateCall(...args);
+    const change = wrap(encodeGraph(porcelainChange), path);
+    const writtenChange = await this.core.call("write", change, options || {});
+    return unwrapObject(decodeGraph(writtenChange), decodePath(path));
+  }
+}
+export { Graffy as default };

package/package.json

@@ -2,8 +2,13 @@
   "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.8-alpha.2",
-  "main": "./cjs/index.js",
+  "version": "0.15.8",
+  "main": "./index.cjs",
+  "exports": {
+    "import": "./index.mjs",
+    "require": "./index.cjs"
+  },
+  "module": "./index.mjs",
   "types": "./types/index.d.ts",
   "repository": {
     "type": "git",
@@ -11,10 +16,9 @@
   },
   "license": "Apache-2.0",
   "dependencies": {
-    "@babel/runtime-corejs3": "^7.15.3",
-    "@graffy/common": "0.15.8-alpha.2",
+    "@graffy/common": "0.15.8",
+    "@graffy/stream": "0.15.8",
     "debug": "^4.3.2",
-    "@graffy/testing": "0.15.8-alpha.2",
-    "@graffy/stream": "0.15.8-alpha.2"
+    "@graffy/testing": "0.15.8"
   }
 }

package/cjs/Core.js

@@ -1,76 +0,0 @@
-"use strict";
-
-var _interopRequireDefault = require("@babel/runtime-corejs3/helpers/interopRequireDefault");
-
-exports.__esModule = true;
-exports.default = void 0;
-
-var _stringify = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/json/stringify"));
-
-var _common = require("@graffy/common");
-
-var _debug = _interopRequireDefault(require("debug"));
-
-var _testing = require("@graffy/testing");
-
-var log = (0, _debug.default)('graffy:core');
-
-function resolve(handlers, firstPayload, options) {
-  if (!handlers || !handlers.length) throw Error('resolve.no_provider');
-
-  function run(i, payload) {
-    if (i >= handlers.length) {
-      throw Error('resolve.no_providers_for ' + (0, _stringify.default)(payload));
-    }
-
-    var _handlers$i = handlers[i],
-        path = _handlers$i.path,
-        handle = _handlers$i.handle;
-    if (!(0, _common.unwrap)(payload, path)) return run(i + 1, payload);
-    var nextCalled = false;
-    return handle(payload, options, function (nextPayload) {
-      if (nextCalled) {
-        throw Error('resolve.duplicate_next_call: ' + handlers[i].name);
-      }
-
-      if (typeof nextPayload === 'undefined') {
-        throw Error('resolve.next_without_payload: ' + handlers[i].name);
-      }
-
-      nextCalled = true;
-      return run(i + 1, nextPayload);
-    });
-  }
-
-  return run(0, firstPayload);
-}
-
-var Core = /*#__PURE__*/function () {
-  function Core() {
-    this.handlers = {};
-  }
-
-  var _proto = Core.prototype;
-
-  _proto.on = function on(type, path, handle) {
-    this.handlers[type] = this.handlers[type] || [];
-    this.handlers[type].push({
-      path: path,
-      handle: handle
-    });
-  };
-
-  _proto.call = function call(type, payload, options) {
-    if (options === void 0) {
-      options = {};
-    }
-
-    log('call', type, (0, _testing.format)(payload));
-    return resolve(this.handlers[type], payload, options);
-  };
-
-  return Core;
-}();
-
-exports.default = Core;
-module.exports = exports.default;

package/cjs/Graffy.js

@@ -1,362 +0,0 @@
-"use strict";
-
-var _interopRequireDefault = require("@babel/runtime-corejs3/helpers/interopRequireDefault");
-
-exports.__esModule = true;
-exports.default = void 0;
-
-var _regenerator = _interopRequireDefault(require("@babel/runtime-corejs3/regenerator"));
-
-var _concat = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/instance/concat"));
-
-var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime-corejs3/helpers/asyncToGenerator"));
-
-var _asyncIterator2 = _interopRequireDefault(require("@babel/runtime-corejs3/helpers/asyncIterator"));
-
-var _common = require("@graffy/common");
-
-var _stream = require("@graffy/stream");
-
-var _validate = require("./validate.js");
-
-var _shift = require("./shift.js");
-
-var _Core = _interopRequireDefault(require("./Core.js"));
-
-var Graffy = /*#__PURE__*/function () {
-  function Graffy(path, core) {
-    if (path === void 0) {
-      path = [];
-    }
-
-    if (core === void 0) {
-      core = new _Core.default();
-    }
-
-    this.core = core;
-    this.path = path;
-  }
-
-  var _proto = Graffy.prototype;
-
-  _proto.on = function on(type) {
-    var _context;
-
-    for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
-      args[_key - 1] = arguments[_key];
-    }
-
-    var _validateOn = _validate.validateOn.apply(void 0, args),
-        pathArg = _validateOn[0],
-        handler = _validateOn[1];
-
-    var path = (0, _concat.default)(_context = this.path).call(_context, pathArg);
-    this.core.on(type, path, handler);
-  };
-
-  _proto.onRead = function onRead() {
-    var _context2;
-
-    var _validateOn2 = _validate.validateOn.apply(void 0, arguments),
-        pathArg = _validateOn2[0],
-        handle = _validateOn2[1];
-
-    var path = (0, _concat.default)(_context2 = this.path).call(_context2, pathArg);
-    this.core.on('read', path, (0, _shift.shiftFn)( /*#__PURE__*/function () {
-      var _porcelainRead = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee(query, options) {
-        var decoded, encoded, finalized;
-        return _regenerator.default.wrap(function _callee$(_context3) {
-          while (1) {
-            switch (_context3.prev = _context3.next) {
-              case 0:
-                // console.log('onRead', path, query);
-                decoded = (0, _common.decodeQuery)(query); // console.log('decoded', path, decoded);
-
-                _context3.t0 = _common.encodeGraph;
-                _context3.next = 4;
-                return handle(decoded, options);
-
-              case 4:
-                _context3.t1 = _context3.sent;
-                encoded = (0, _context3.t0)(_context3.t1);
-                // console.log({ encoded });
-                finalized = (0, _common.finalize)(encoded, query); // console.log({ finalized });
-
-                return _context3.abrupt("return", finalized);
-
-              case 8:
-              case "end":
-                return _context3.stop();
-            }
-          }
-        }, _callee);
-      }));
-
-      function porcelainRead(_x, _x2) {
-        return _porcelainRead.apply(this, arguments);
-      }
-
-      return porcelainRead;
-    }(), path));
-  };
-
-  _proto.onWatch = function onWatch() {
-    var _context4;
-
-    var _validateOn3 = _validate.validateOn.apply(void 0, arguments),
-        pathArg = _validateOn3[0],
-        handle = _validateOn3[1];
-
-    var path = (0, _concat.default)(_context4 = this.path).call(_context4, pathArg);
-    this.core.on('watch', path, (0, _shift.shiftGen)(function porcelainWatch(query, options) {
-      return (0, _stream.makeStream)(function (push, end) {
-        var subscription = handle((0, _common.decodeQuery)(query), options);
-        (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee2() {
-          var firstValue, _iteratorAbruptCompletion, _didIteratorError, _iteratorError, _iterator, _step, value;
-
-          return _regenerator.default.wrap(function _callee2$(_context5) {
-            while (1) {
-              switch (_context5.prev = _context5.next) {
-                case 0:
-                  _context5.prev = 0;
-                  _context5.next = 3;
-                  return subscription.next();
-
-                case 3:
-                  firstValue = _context5.sent.value;
-                  push(firstValue && (0, _common.finalize)((0, _common.encodeGraph)(firstValue), query));
-                  _iteratorAbruptCompletion = false;
-                  _didIteratorError = false;
-                  _context5.prev = 7;
-                  _iterator = (0, _asyncIterator2.default)(subscription);
-
-                case 9:
-                  _context5.next = 11;
-                  return _iterator.next();
-
-                case 11:
-                  if (!(_iteratorAbruptCompletion = !(_step = _context5.sent).done)) {
-                    _context5.next = 17;
-                    break;
-                  }
-
-                  value = _step.value;
-                  push(value && (0, _common.encodeGraph)(value));
-
-                case 14:
-                  _iteratorAbruptCompletion = false;
-                  _context5.next = 9;
-                  break;
-
-                case 17:
-                  _context5.next = 23;
-                  break;
-
-                case 19:
-                  _context5.prev = 19;
-                  _context5.t0 = _context5["catch"](7);
-                  _didIteratorError = true;
-                  _iteratorError = _context5.t0;
-
-                case 23:
-                  _context5.prev = 23;
-                  _context5.prev = 24;
-
-                  if (!(_iteratorAbruptCompletion && _iterator.return != null)) {
-                    _context5.next = 28;
-                    break;
-                  }
-
-                  _context5.next = 28;
-                  return _iterator.return();
-
-                case 28:
-                  _context5.prev = 28;
-
-                  if (!_didIteratorError) {
-                    _context5.next = 31;
-                    break;
-                  }
-
-                  throw _iteratorError;
-
-                case 31:
-                  return _context5.finish(28);
-
-                case 32:
-                  return _context5.finish(23);
-
-                case 33:
-                  _context5.next = 38;
-                  break;
-
-                case 35:
-                  _context5.prev = 35;
-                  _context5.t1 = _context5["catch"](0);
-                  end(_context5.t1);
-
-                case 38:
-                case "end":
-                  return _context5.stop();
-              }
-            }
-          }, _callee2, null, [[0, 35], [7, 19, 23, 33], [24,, 28, 32]]);
-        }))();
-        return function () {
-          return subscription.return();
-        };
-      });
-    }, path));
-  };
-
-  _proto.onWrite = function onWrite() {
-    var _context6;
-
-    var _validateOn4 = _validate.validateOn.apply(void 0, arguments),
-        pathArg = _validateOn4[0],
-        handle = _validateOn4[1];
-
-    var path = (0, _concat.default)(_context6 = this.path).call(_context6, pathArg);
-    this.core.on('write', path, (0, _shift.shiftFn)( /*#__PURE__*/function () {
-      var _porcelainWrite = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee3(change, options) {
-        return _regenerator.default.wrap(function _callee3$(_context7) {
-          while (1) {
-            switch (_context7.prev = _context7.next) {
-              case 0:
-                _context7.t0 = _common.encodeGraph;
-                _context7.next = 3;
-                return handle((0, _common.decodeGraph)(change), options);
-
-              case 3:
-                _context7.t1 = _context7.sent;
-                return _context7.abrupt("return", (0, _context7.t0)(_context7.t1));
-
-              case 5:
-              case "end":
-                return _context7.stop();
-            }
-          }
-        }, _callee3);
-      }));
-
-      function porcelainWrite(_x3, _x4) {
-        return _porcelainWrite.apply(this, arguments);
-      }
-
-      return porcelainWrite;
-    }(), path));
-  };
-
-  _proto.use = function use() {
-    var _validateOn5 = _validate.validateOn.apply(void 0, arguments),
-        path = _validateOn5[0],
-        provider = _validateOn5[1];
-
-    provider(new Graffy(path, this.core));
-  };
-
-  _proto.call = function call(type, payload, options) {
-    if (options === void 0) {
-      options = {};
-    }
-
-    return this.core.call(type, payload, options);
-  };
-
-  _proto.read = /*#__PURE__*/function () {
-    var _read = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee4() {
-      var _validateCall,
-          path,
-          porcelainQuery,
-          options,
-          rootQuery,
-          query,
-          result,
-          _args4 = arguments;
-
-      return _regenerator.default.wrap(function _callee4$(_context8) {
-        while (1) {
-          switch (_context8.prev = _context8.next) {
-            case 0:
-              _validateCall = _validate.validateCall.apply(void 0, _args4), path = _validateCall[0], porcelainQuery = _validateCall[1], options = _validateCall[2];
-              rootQuery = (0, _common.wrapObject)(porcelainQuery, path);
-              query = (0, _common.encodeQuery)(rootQuery);
-              _context8.next = 5;
-              return this.core.call('read', query, options || {});
-
-            case 5:
-              result = _context8.sent;
-              return _context8.abrupt("return", (0, _common.unwrapObject)((0, _common.decorate)(result, rootQuery), (0, _common.decodePath)(path)));
-
-            case 7:
-            case "end":
-              return _context8.stop();
-          }
-        }
-      }, _callee4, this);
-    }));
-
-    function read() {
-      return _read.apply(this, arguments);
-    }
-
-    return read;
-  }();
-
-  _proto.watch = function watch() {
-    var _validateCall2 = _validate.validateCall.apply(void 0, arguments),
-        path = _validateCall2[0],
-        porcelainQuery = _validateCall2[1],
-        options = _validateCall2[2];
-
-    var rootQuery = (0, _common.wrapObject)(porcelainQuery, path);
-    var query = (0, _common.encodeQuery)(rootQuery);
-    var stream = this.core.call('watch', query, options || {});
-    return (0, _stream.mapStream)(stream, function (value) {
-      return (0, _common.unwrapObject)((0, _common.decorate)(value, rootQuery), (0, _common.decodePath)(path));
-    });
-  };
-
-  _proto.write = /*#__PURE__*/function () {
-    var _write = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee5() {
-      var _validateCall3,
-          path,
-          porcelainChange,
-          options,
-          change,
-          writtenChange,
-          _args5 = arguments;
-
-      return _regenerator.default.wrap(function _callee5$(_context9) {
-        while (1) {
-          switch (_context9.prev = _context9.next) {
-            case 0:
-              _validateCall3 = _validate.validateCall.apply(void 0, _args5), path = _validateCall3[0], porcelainChange = _validateCall3[1], options = _validateCall3[2];
-              change = (0, _common.wrap)((0, _common.encodeGraph)(porcelainChange), path);
-              _context9.next = 4;
-              return this.core.call('write', change, options || {});
-
-            case 4:
-              writtenChange = _context9.sent;
-              return _context9.abrupt("return", (0, _common.unwrapObject)((0, _common.decodeGraph)(writtenChange), (0, _common.decodePath)(path)));
-
-            case 6:
-            case "end":
-              return _context9.stop();
-          }
-        }
-      }, _callee5, this);
-    }));
-
-    function write() {
-      return _write.apply(this, arguments);
-    }
-
-    return write;
-  }();
-
-  return Graffy;
-}();
-
-exports.default = Graffy;
-module.exports = exports.default;

package/cjs/index.js

@@ -1,12 +0,0 @@
-"use strict";
-
-var _interopRequireDefault = require("@babel/runtime-corejs3/helpers/interopRequireDefault");
-
-exports.__esModule = true;
-exports.default = void 0;
-
-var _Graffy = _interopRequireDefault(require("./Graffy.js"));
-
-var _default = _Graffy.default;
-exports.default = _default;
-module.exports = exports.default;

package/cjs/shift.js

@@ -1,350 +0,0 @@
-"use strict";
-
-var _interopRequireDefault = require("@babel/runtime-corejs3/helpers/interopRequireDefault");
-
-exports.__esModule = true;
-exports.shiftFn = shiftFn;
-exports.shiftGen = shiftGen;
-
-var _promise = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/promise"));
-
-var _regenerator = _interopRequireDefault(require("@babel/runtime-corejs3/regenerator"));
-
-var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime-corejs3/helpers/asyncToGenerator"));
-
-var _wrapAsyncGenerator2 = _interopRequireDefault(require("@babel/runtime-corejs3/helpers/wrapAsyncGenerator"));
-
-var _awaitAsyncGenerator2 = _interopRequireDefault(require("@babel/runtime-corejs3/helpers/awaitAsyncGenerator"));
-
-var _asyncGeneratorDelegate2 = _interopRequireDefault(require("@babel/runtime-corejs3/helpers/asyncGeneratorDelegate"));
-
-var _asyncIterator2 = _interopRequireDefault(require("@babel/runtime-corejs3/helpers/asyncIterator"));
-
-var _common = require("@graffy/common");
-
-var _stream = require("@graffy/stream");
-
-// import { format } from '@graffy/testing';
-function mapStream(stream, fn) {
-  var _iteratorAbruptCompletion, _didIteratorError, _iteratorError, _iterator, _step, value;
-
-  return _regenerator.default.async(function mapStream$(_context) {
-    while (1) {
-      switch (_context.prev = _context.next) {
-        case 0:
-          _iteratorAbruptCompletion = false;
-          _didIteratorError = false;
-          _context.prev = 2;
-          _iterator = (0, _asyncIterator2.default)(stream);
-
-        case 4:
-          _context.next = 6;
-          return _regenerator.default.awrap(_iterator.next());
-
-        case 6:
-          if (!(_iteratorAbruptCompletion = !(_step = _context.sent).done)) {
-            _context.next = 12;
-            break;
-          }
-
-          value = _step.value;
-          fn(value);
-
-        case 9:
-          _iteratorAbruptCompletion = false;
-          _context.next = 4;
-          break;
-
-        case 12:
-          _context.next = 18;
-          break;
-
-        case 14:
-          _context.prev = 14;
-          _context.t0 = _context["catch"](2);
-          _didIteratorError = true;
-          _iteratorError = _context.t0;
-
-        case 18:
-          _context.prev = 18;
-          _context.prev = 19;
-
-          if (!(_iteratorAbruptCompletion && _iterator.return != null)) {
-            _context.next = 23;
-            break;
-          }
-
-          _context.next = 23;
-          return _regenerator.default.awrap(_iterator.return());
-
-        case 23:
-          _context.prev = 23;
-
-          if (!_didIteratorError) {
-            _context.next = 26;
-            break;
-          }
-
-          throw _iteratorError;
-
-        case 26:
-          return _context.finish(23);
-
-        case 27:
-          return _context.finish(18);
-
-        case 28:
-        case "end":
-          return _context.stop();
-      }
-    }
-  }, null, null, [[2, 14, 18, 28], [19,, 23, 27]], _promise.default);
-}
-
-function shiftFn(fn, path) {
-  return /*#__PURE__*/function () {
-    var _shiftedFn = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee2(payload, options, next) {
-      var nextCalled, remainingNextResult, unwrappedPayload, remainingPayload, shiftedNext, _shiftedNext, rawResult, result;
-
-      return _regenerator.default.wrap(function _callee2$(_context3) {
-        while (1) {
-          switch (_context3.prev = _context3.next) {
-            case 0:
-              _shiftedNext = function _shiftedNext3() {
-                _shiftedNext = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee(unwrappedNextPayload) {
-                  var nextPayload, nextResult;
-                  return _regenerator.default.wrap(function _callee$(_context2) {
-                    while (1) {
-                      switch (_context2.prev = _context2.next) {
-                        case 0:
-                          nextCalled = true;
-                          nextPayload = (0, _common.wrap)(unwrappedNextPayload, path);
-                          if (remainingPayload.length) (0, _common.merge)(nextPayload, remainingPayload);
-                          _context2.next = 5;
-                          return next(nextPayload);
-
-                        case 5:
-                          nextResult = _context2.sent;
-                          // Remember the next() results that are not returned to this provider.
-                          // These will be merged into the result later.
-                          remainingNextResult = (0, _common.remove)(nextResult, path) || [];
-                          return _context2.abrupt("return", (0, _common.unwrap)(nextResult, path));
-
-                        case 8:
-                        case "end":
-                          return _context2.stop();
-                      }
-                    }
-                  }, _callee);
-                }));
-                return _shiftedNext.apply(this, arguments);
-              };
-
-              shiftedNext = function _shiftedNext2(_x8) {
-                return _shiftedNext.apply(this, arguments);
-              };
-
-              nextCalled = false;
-              unwrappedPayload = (0, _common.unwrap)(payload, path);
-              remainingPayload = (0, _common.remove)(payload, path) || []; // This next function is offered to the provider function.
-
-              _context3.next = 7;
-              return fn(unwrappedPayload, options, shiftedNext);
-
-            case 7:
-              rawResult = _context3.sent;
-              // console.log(rawResult, path);
-              result = (0, _common.wrap)(rawResult, path); // console.log(result);
-
-              if (!(!nextCalled && remainingPayload.length)) {
-                _context3.next = 13;
-                break;
-              }
-
-              _context3.next = 12;
-              return next(remainingPayload);
-
-            case 12:
-              remainingNextResult = _context3.sent;
-
-            case 13:
-              if (remainingNextResult && remainingNextResult.length) {
-                (0, _common.merge)(result, remainingNextResult);
-              } // console.log('Shifted', path, format(payload), format(result));
-
-
-              return _context3.abrupt("return", result);
-
-            case 15:
-            case "end":
-              return _context3.stop();
-          }
-        }
-      }, _callee2);
-    }));
-
-    function shiftedFn(_x5, _x6, _x7) {
-      return _shiftedFn.apply(this, arguments);
-    }
-
-    return shiftedFn;
-  }();
-} // TODO: Provider calling next in a subscription function is not tested.
-
-
-function shiftGen(fn, path) {
-  return /*#__PURE__*/function () {
-    var _shiftedGen = (0, _wrapAsyncGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee4(payload, options, next) {
-      var nextCalled, remainingNextStream, unwrappedPayload, remainingPayload, shiftedNext, unwrappedStream, firstValue, resultStream;
-      return _regenerator.default.wrap(function _callee4$(_context5) {
-        while (1) {
-          switch (_context5.prev = _context5.next) {
-            case 0:
-              nextCalled = false;
-              unwrappedPayload = (0, _common.unwrap)(payload, path);
-              remainingPayload = (0, _common.remove)(payload, path) || []; // TODO: This should probably use makeStream and propagate returns.
-
-              shiftedNext = /*#__PURE__*/function () {
-                var _shiftedNextFn = (0, _wrapAsyncGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee3(unwrappedNextPayload) {
-                  var nextPayload, pushRemaining, _iteratorAbruptCompletion2, _didIteratorError2, _iteratorError2, _iterator2, _step2, value, unwrappedValue, remainingValue;
-
-                  return _regenerator.default.wrap(function _callee3$(_context4) {
-                    while (1) {
-                      switch (_context4.prev = _context4.next) {
-                        case 0:
-                          nextCalled = true;
-                          nextPayload = (0, _common.wrap)(unwrappedNextPayload, path);
-                          if (remainingPayload.length) (0, _common.merge)(nextPayload, remainingPayload);
-                          remainingNextStream = (0, _stream.makeStream)(function (push) {
-                            pushRemaining = push;
-                          });
-                          _iteratorAbruptCompletion2 = false;
-                          _didIteratorError2 = false;
-                          _context4.prev = 6;
-                          _iterator2 = (0, _asyncIterator2.default)(next(nextPayload));
-
-                        case 8:
-                          _context4.next = 10;
-                          return (0, _awaitAsyncGenerator2.default)(_iterator2.next());
-
-                        case 10:
-                          if (!(_iteratorAbruptCompletion2 = !(_step2 = _context4.sent).done)) {
-                            _context4.next = 21;
-                            break;
-                          }
-
-                          value = _step2.value;
-                          unwrappedValue = (0, _common.unwrap)(value, path);
-                          remainingValue = (0, _common.remove)(value, path);
-                          if (remainingValue) pushRemaining(remainingValue);
-
-                          if (!unwrappedValue) {
-                            _context4.next = 18;
-                            break;
-                          }
-
-                          _context4.next = 18;
-                          return unwrappedValue;
-
-                        case 18:
-                          _iteratorAbruptCompletion2 = false;
-                          _context4.next = 8;
-                          break;
-
-                        case 21:
-                          _context4.next = 27;
-                          break;
-
-                        case 23:
-                          _context4.prev = 23;
-                          _context4.t0 = _context4["catch"](6);
-                          _didIteratorError2 = true;
-                          _iteratorError2 = _context4.t0;
-
-                        case 27:
-                          _context4.prev = 27;
-                          _context4.prev = 28;
-
-                          if (!(_iteratorAbruptCompletion2 && _iterator2.return != null)) {
-                            _context4.next = 32;
-                            break;
-                          }
-
-                          _context4.next = 32;
-                          return (0, _awaitAsyncGenerator2.default)(_iterator2.return());
-
-                        case 32:
-                          _context4.prev = 32;
-
-                          if (!_didIteratorError2) {
-                            _context4.next = 35;
-                            break;
-                          }
-
-                          throw _iteratorError2;
-
-                        case 35:
-                          return _context4.finish(32);
-
-                        case 36:
-                          return _context4.finish(27);
-
-                        case 37:
-                        case "end":
-                          return _context4.stop();
-                      }
-                    }
-                  }, _callee3, null, [[6, 23, 27, 37], [28,, 32, 36]]);
-                }));
-
-                function shiftedNextFn(_x4) {
-                  return _shiftedNextFn.apply(this, arguments);
-                }
-
-                return shiftedNextFn;
-              }();
-
-              unwrappedStream = fn(unwrappedPayload, options, shiftedNext); // We expect next() to be called before the first value is yielded.
-
-              _context5.t0 = _awaitAsyncGenerator2.default;
-              _context5.next = 8;
-              return (0, _awaitAsyncGenerator2.default)(unwrappedStream.next());
-
-            case 8:
-              _context5.t1 = _context5.sent.value;
-              _context5.next = 11;
-              return (0, _context5.t0)(_context5.t1);
-
-            case 11:
-              firstValue = _context5.sent;
-              resultStream = (0, _stream.makeStream)(function (push) {
-                push((0, _common.wrap)(firstValue, path));
-                mapStream(unwrappedStream, function (value) {
-                  push((0, _common.wrap)(value, path));
-                });
-                return function () {
-                  return unwrappedStream.return();
-                };
-              });
-
-              if (!nextCalled && remainingPayload.length) {
-                remainingNextStream = next(remainingPayload);
-              }
-
-              return _context5.delegateYield((0, _asyncGeneratorDelegate2.default)((0, _asyncIterator2.default)(remainingNextStream ? (0, _common.mergeStreams)(resultStream, remainingNextStream) : resultStream), _awaitAsyncGenerator2.default), "t2", 15);
-
-            case 15:
-            case "end":
-              return _context5.stop();
-          }
-        }
-      }, _callee4);
-    }));
-
-    function shiftedGen(_x, _x2, _x3) {
-      return _shiftedGen.apply(this, arguments);
-    }
-
-    return shiftedGen;
-  }();
-}

package/cjs/validate.js

@@ -1,76 +0,0 @@
-"use strict";
-
-var _interopRequireDefault = require("@babel/runtime-corejs3/helpers/interopRequireDefault");
-
-exports.__esModule = true;
-exports.validateCall = validateCall;
-exports.validateOn = validateOn;
-
-var _isArray = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/array/is-array"));
-
-var _stringify = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/json/stringify"));
-
-var _common = require("@graffy/common");
-
-function isPlainObject(obj) {
-  return obj && typeof obj === 'object' && !(0, _isArray.default)(obj);
-}
-/*
-any -> payload
-
-object, object -> payload, options
-string | array, any -> path, payload
-
-string | array, any, object -> path, payload, options
-*/
-
-
-function validateCall() {
-  for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
-    args[_key] = arguments[_key];
-  }
-
-  if (args.length === 1) {
-    return [[], args[0], {}];
-  } else if (args.length === 2) {
-    if (isPlainObject(args[0])) {
-      if (!isPlainObject(args[1])) {
-        throw Error("validateCall.invalid_options: " + (0, _stringify.default)(args[1]));
-      }
-
-      return [[], args[0], args[1]];
-    } else {
-      return [(0, _common.encodePath)(args[0]), args[1], {}];
-    }
-  } else if (args.length === 3) {
-    if (!isPlainObject(args[2])) {
-      throw Error("validateCall.invalid_options: " + (0, _stringify.default)(args[1]));
-    }
-
-    return [(0, _common.encodePath)(args[0]), args[1], args[2]];
-  }
-
-  throw Error("validateCall.invalid_args: " + (0, _stringify.default)(args));
-}
-
-function validateOn() {
-  for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
-    args[_key2] = arguments[_key2];
-  }
-
-  if (args.length === 1) {
-    if (typeof args[0] !== 'function') {
-      throw Error("validateOn.invalid_handler: " + (0, _stringify.default)(args[0]));
-    }
-
-    return [[], args[0]];
-  } else if (args.length === 2) {
-    if (typeof args[1] !== 'function') {
-      throw Error("validateOn.invalid_handler: " + (0, _stringify.default)(args[1]));
-    }
-
-    return [(0, _common.encodePath)(args[0]), args[1]];
-  }
-
-  throw Error("validateOn.invalid_args: " + (0, _stringify.default)(args));
-}

package/cjs/wrapProvider.js

@@ -1,33 +0,0 @@
-"use strict";
-
-var _interopRequireDefault = require("@babel/runtime-corejs3/helpers/interopRequireDefault");
-
-exports.__esModule = true;
-exports.default = wrapProvider;
-
-var _wrappers = _interopRequireDefault(require("./wrappers.js"));
-
-function wrapProvider(provider, options) {
-  if (options === void 0) {
-    options = {};
-  }
-
-  var _options = options,
-      decode = _options.decode,
-      shift = _options.shift,
-      finalize = _options.finalize,
-      _debounce = _options._debounce,
-      link = _options.link,
-      _fetch = _options._fetch,
-      _watch = _options._watch;
-  /*
-    The wrapper closest to the user-supplied provider should be applied first.
-  */
-
-  if (shift) provider = _wrappers.default.shift(provider, shift);
-  if (link) provider = _wrappers.default.link(provider, link);
-  if (finalize) provider = _wrappers.default.finalize(provider);
-  if (decode) provider = _wrappers.default.decode(provider);
-}
-
-module.exports = exports.default;