@graffy/core 0.15.25-alpha.3 → 0.15.25-alpha.5

package/package.json

@@ -2,13 +2,8 @@
   "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.3",
-  "main": "./index.cjs",
-  "exports": {
-    "import": "./index.mjs",
-    "require": "./index.cjs"
-  },
-  "module": "./index.mjs",
+  "version": "0.15.25-alpha.5",
+  "main": "./index.mjs",
   "types": "./types/index.d.ts",
   "repository": {
     "type": "git",
@@ -16,8 +11,8 @@
   },
   "license": "Apache-2.0",
   "dependencies": {
-    "@graffy/common": "0.15.25-alpha.3",
-    "@graffy/stream": "0.15.25-alpha.3",
+    "@graffy/common": "0.15.25-alpha.5",
+    "@graffy/stream": "0.15.25-alpha.5",
     "debug": "^4.3.3"
   }
 }

package/index.cjs

@@ -1,243 +0,0 @@
-"use strict";
-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);
-}
-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, firstOptions) {
-  if (!handlers || !handlers.length)
-    throw Error("resolve.no_provider");
-  function run(i, payload, options) {
-    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, options);
-    let nextCalled = false;
-    return handle(payload, options, (nextPayload, nextOptions) => {
-      if (nextCalled) {
-        throw Error("resolve.duplicate_next_call: " + handlers[i].name);
-      }
-      nextCalled = true;
-      if (typeof nextPayload === "undefined" || !nextPayload.length)
-        return;
-      return run(i + 1, nextPayload, nextOptions || options);
-    });
-  }
-  return run(0, firstPayload, firstOptions);
-}
-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, 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 [pathArg, provider] = validateOn(...args);
-    const path = this.path.concat(pathArg);
-    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.encodeGraph(common.wrapObject(porcelainChange, path));
-    const writtenChange = await this.core.call("write", change, options || {});
-    return common.unwrapObject(common.decodeGraph(writtenChange), common.decodePath(path));
-  }
-}
-module.exports = Graffy;