@graffy/core 0.18.1-alpha.2 → 0.19.1-alpha.1

package/{types/Core.d.ts → Core.d.ts}

@@ -1,5 +1,5 @@
 export default class Core {
-    handlers: {};
+    constructor();
     on(type: any, path: any, handle: any): void;
     call(type: any, payload: any, options?: {}): any;
 }

package/Core.js

@@ -0,0 +1,40 @@
+import { encodePath, unwrap } from '@graffy/common';
+import debug from 'debug';
+const log = debug('graffy:core');
+function resolve(handlers, firstPayload, firstOptions) {
+    if (!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 (!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);
+}
+export default class Core {
+    constructor() {
+        this.handlers = {};
+    }
+    on(type, path, handle) {
+        this.handlers[type] = this.handlers[type] || [];
+        this.handlers[type].push({ path: encodePath(path), handle });
+    }
+    call(type, payload, options = {}) {
+        log('call', type, payload);
+        return resolve(this.handlers[type], payload, options);
+    }
+}

package/{types/Graffy.d.ts → Graffy.d.ts}

@@ -1,8 +1,7 @@
-export { unchanged } from "./shift.js";
-declare class Graffy {
+import Core from './Core.js';
+export { unchanged } from './shift.js';
+export default class Graffy {
     constructor(path?: any[], core?: Core);
-    core: Core;
-    path: any[];
     on(type: any, ...args: any[]): void;
     onRead(...args: any[]): void;
     onWatch(...args: any[]): void;
@@ -13,21 +12,9 @@ declare class Graffy {
     watch(...args: any[]): {
         debugId: any;
         next: () => any;
-        return(value: any): Promise<{
-            value: any;
-            done: boolean;
-        }>;
-        throw(error: any): Promise<{
-            value: any;
-            done: boolean;
-        }>;
-        [Symbol.asyncIterator](): /*elided*/ any;
+        return(value: any): any;
+        throw(error: any): any;
+        [Symbol.asyncIterator](): any;
     };
     write(...args: any[]): Promise<any>;
 }
-declare namespace Graffy {
-    export { unchanged };
-}
-export default Graffy;
-import Core from './Core.js';
-import { unchanged } from './shift.js';

package/Graffy.js

@@ -0,0 +1,81 @@
+import { decodeGraph, decodeQuery, decorate, encodeGraph, encodeQuery, finalize, unwrapObject, wrapObject, } from '@graffy/common';
+import { makeStream, mapStream } from '@graffy/stream';
+import Core from "./Core.js";
+import { shiftGen, unchanged, wrapProvider } from "./shift.js";
+import { validateCall, validateOn } from "./validate.js";
+export { unchanged } from "./shift.js";
+export default 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, wrapProvider(handle, path, true));
+    }
+    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, () => {
+                    // TODO: Implement this using mergeStreams
+                    throw Error(`porcelain.watch_next_unsupported: ${path}`);
+                });
+                (async () => {
+                    try {
+                        const 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, wrapProvider(handle, path, false));
+    }
+    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 = wrapObject(porcelainQuery, path);
+        const query = encodeQuery(rootQuery);
+        const result = await this.core.call('read', query, options || {});
+        return unwrapObject(decorate(result, rootQuery), 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(stream, (value) => unwrapObject(decorate(value, rootQuery), path));
+    }
+    async write(...args) {
+        const [path, porcelainChange, options] = validateCall(...args);
+        const change = encodeGraph(wrapObject(porcelainChange, path));
+        const writtenChange = await this.core.call('write', change, options || {});
+        return unwrapObject(decodeGraph(writtenChange), path);
+    }
+}
+Graffy.unchanged = unchanged;

package/index.js

@@ -0,0 +1,2 @@
+import Graffy from "./Graffy.js";
+export default Graffy;

package/package.json

@@ -2,22 +2,27 @@
   "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.18.1-alpha.2",
-  "main": "./index.cjs",
+  "version": "0.19.1-alpha.1",
+  "main": "./cjs/index.js",
   "exports": {
-    "import": "./index.mjs",
-    "require": "./index.cjs"
+    ".": {
+      "import": "./index.js",
+      "types": "./index.d.ts"
+    },
+    "./*": {
+      "import": "./*.js",
+      "types": "./*.d.ts"
+    }
   },
-  "module": "./index.mjs",
-  "types": "./types/index.d.ts",
+  "types": "./index.d.ts",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/usegraffy/graffy.git"
   },
   "license": "Apache-2.0",
   "dependencies": {
-    "@graffy/common": "0.18.1-alpha.2",
-    "@graffy/stream": "0.18.1-alpha.2",
-    "debug": "^4.4.3"
+    "@graffy/common": "0.19.1-alpha.1",
+    "debug": "^4.4.3",
+    "@graffy/stream": "0.19.1-alpha.1"
   }
 }

package/shift.d.ts

@@ -0,0 +1,3 @@
+export declare const unchanged: unique symbol;
+export declare function wrapProvider(fn: any, decodedPath: any, isRead: any): (payload: any, options: any, next: any) => Promise<any>;
+export declare function shiftGen(fn: any, path: any): (payload: any, options: any, next: any) => AsyncGenerator<any, void, any>;

package/shift.js

@@ -0,0 +1,121 @@
+import { encodeGraph, encodePath, encodeQuery, finalize, merge, mergeStreams, decodeGraph as origDecodeGraph, decodeQuery as origDecodeQuery, remove, unwrap, unwrapObject, wrap, wrapObject, } from '@graffy/common';
+import { makeStream } from '@graffy/stream';
+async function mapStream(stream, fn) {
+    for await (const value of stream) {
+        fn(value);
+    }
+}
+export const unchanged = Symbol('Payload or result unchanged by handler');
+const decodeCache = new WeakMap();
+function memoizeDecode(origDecode) {
+    return (payload) => {
+        if (decodeCache.has(payload))
+            return decodeCache.get(payload);
+        const decoded = origDecode(payload);
+        if (payload.type === 'object' && payload)
+            decodeCache.set(payload, decoded);
+        return decoded;
+    };
+}
+const decodeGraph = memoizeDecode(origDecodeGraph);
+const decodeQuery = memoizeDecode(origDecodeQuery);
+export function wrapProvider(fn, decodedPath, isRead) {
+    const decodePayload = isRead ? decodeQuery : decodeGraph;
+    const encodePayload = isRead ? encodeQuery : encodeGraph;
+    const path = encodePath(decodedPath);
+    return async function wrappedProvider(payload, options, next) {
+        let nextCalled = false;
+        let nextResult;
+        let remainingNextResult;
+        const porcelainPayload = unwrapObject(decodePayload(payload), decodedPath);
+        const remainingPayload = remove(payload, path) || [];
+        // This next function is offered to the provider function.
+        async function shiftedNext(porcelainNextPayload, nextOptions) {
+            nextCalled = true;
+            let nextPayload;
+            if (porcelainNextPayload === unchanged) {
+                nextPayload = payload;
+            }
+            else {
+                nextPayload = encodePayload(wrapObject(porcelainNextPayload, decodedPath));
+                if (remainingPayload.length)
+                    merge(nextPayload, remainingPayload);
+            }
+            nextResult = await next(nextPayload, nextOptions);
+            // Remember the next() results that are not returned to this provider.
+            // These will be merged into the result later.
+            remainingNextResult = remove(nextResult, path) || [];
+            return unwrapObject(decodeGraph(nextResult), decodedPath);
+        }
+        const porcelainResult = await fn(porcelainPayload, options, shiftedNext);
+        let result;
+        if (porcelainResult === unchanged) {
+            result = nextResult;
+        }
+        else {
+            result = encodeGraph(wrapObject(porcelainResult, decodedPath));
+            // TODO: Get rid of this special handling by requiring read providers to
+            // finalize results themselves.
+            if (isRead && !nextCalled) {
+                // This does the opposite of "remove"; "keep"?
+                const appliedQuery = wrap(unwrap(payload, path), path);
+                result = finalize(result, appliedQuery);
+                result = wrap(unwrap(result, path), path);
+            }
+            if (!nextCalled && remainingPayload.length) {
+                remainingNextResult = await next(remainingPayload);
+            }
+            if (remainingNextResult?.length) {
+                merge(result, remainingNextResult);
+            }
+        }
+        // console.log('Shifted', path, format(payload), format(result));
+        return result;
+    };
+}
+// TODO: Provider calling next in a subscription function is not tested.
+export function shiftGen(fn, path) {
+    path = encodePath(path);
+    return async function* shiftedGen(payload, options, next) {
+        let nextCalled = false;
+        let remainingNextStream;
+        const unwrappedPayload = unwrap(payload, path);
+        const remainingPayload = remove(payload, path) || [];
+        // TODO: This should probably use makeStream and propagate returns.
+        const shiftedNext = async function* shiftedNextFn(unwrappedNextPayload, nextOptions) {
+            nextCalled = true;
+            const nextPayload = wrap(unwrappedNextPayload, path);
+            if (remainingPayload.length)
+                merge(nextPayload, remainingPayload);
+            /** @type {Function} */
+            let pushRemaining;
+            remainingNextStream = makeStream((push) => {
+                pushRemaining = push;
+            });
+            for await (const value of next(nextPayload, nextOptions)) {
+                const unwrappedValue = unwrap(value, path);
+                const remainingValue = remove(value, path);
+                if (remainingValue)
+                    pushRemaining(remainingValue);
+                if (unwrappedValue)
+                    yield unwrappedValue;
+            }
+        };
+        const unwrappedStream = fn(unwrappedPayload, options, shiftedNext);
+        // We expect next() to be called before the first value is yielded.
+        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;
+    };
+}

package/validate.d.ts

@@ -0,0 +1,2 @@
+export declare function validateCall(...args: any[]): any[];
+export declare function validateOn(...args: any[]): any[];

package/validate.js

@@ -0,0 +1,46 @@
+import { isPlainObject } from '@graffy/common';
+const splitPath = (path) => Array.isArray(path) ? path : path === '' ? [] : String(path).split('.');
+/*
+any -> payload
+
+object, object -> payload, options
+string | array, any -> path, payload
+
+string | array, any, object -> path, payload, options
+*/
+export function validateCall(...args) {
+    if (args.length === 1) {
+        return [[], args[0], {}];
+    }
+    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]];
+        }
+        return [splitPath(args[0]), args[1], {}];
+    }
+    if (args.length === 3) {
+        if (!isPlainObject(args[2])) {
+            throw Error(`validateCall.invalid_options: ${JSON.stringify(args[1])}`);
+        }
+        return [splitPath(args[0]), args[1], args[2]];
+    }
+    throw Error(`validateCall.invalid_args: ${JSON.stringify(args)}`);
+}
+export function validateOn(...args) {
+    if (args.length === 1) {
+        if (typeof args[0] !== 'function') {
+            throw Error(`validateOn.invalid_handler: ${JSON.stringify(args[0])}`);
+        }
+        return [[], args[0]];
+    }
+    if (args.length === 2) {
+        if (typeof args[1] !== 'function') {
+            throw Error(`validateOn.invalid_handler: ${JSON.stringify(args[1])}`);
+        }
+        return [splitPath(args[0]), args[1]];
+    }
+    throw Error(`validateOn.invalid_args: ${JSON.stringify(args)}`);
+}

package/index.cjs

@@ -1,258 +0,0 @@
-"use strict";
-const common = require("@graffy/common");
-const stream = require("@graffy/stream");
-const debug = require("debug");
-const log = debug("graffy:core");
-function resolve(handlers, firstPayload, firstOptions) {
-  if (!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: common.encodePath(path), handle });
-  }
-  call(type, payload, options = {}) {
-    log("call", type, payload);
-    return resolve(this.handlers[type], payload, options);
-  }
-}
-async function mapStream(stream2, fn) {
-  for await (const value of stream2) {
-    fn(value);
-  }
-}
-const unchanged = /* @__PURE__ */ Symbol("Payload or result unchanged by handler");
-const decodeCache = /* @__PURE__ */ new WeakMap();
-function memoizeDecode(origDecode) {
-  return (payload) => {
-    if (decodeCache.has(payload)) return decodeCache.get(payload);
-    const decoded = origDecode(payload);
-    if (payload.type === "object" && payload) decodeCache.set(payload, decoded);
-    return decoded;
-  };
-}
-const decodeGraph = memoizeDecode(common.decodeGraph);
-const decodeQuery = memoizeDecode(common.decodeQuery);
-function wrapProvider(fn, decodedPath, isRead) {
-  const decodePayload = isRead ? decodeQuery : decodeGraph;
-  const encodePayload = isRead ? common.encodeQuery : common.encodeGraph;
-  const path = common.encodePath(decodedPath);
-  return async function wrappedProvider(payload, options, next) {
-    let nextCalled = false;
-    let nextResult;
-    let remainingNextResult;
-    const porcelainPayload = common.unwrapObject(decodePayload(payload), decodedPath);
-    const remainingPayload = common.remove(payload, path) || [];
-    async function shiftedNext(porcelainNextPayload, nextOptions) {
-      nextCalled = true;
-      let nextPayload;
-      if (porcelainNextPayload === unchanged) {
-        nextPayload = payload;
-      } else {
-        nextPayload = encodePayload(
-          common.wrapObject(porcelainNextPayload, decodedPath)
-        );
-        if (remainingPayload.length) common.merge(nextPayload, remainingPayload);
-      }
-      nextResult = await next(nextPayload, nextOptions);
-      remainingNextResult = common.remove(nextResult, path) || [];
-      return common.unwrapObject(decodeGraph(nextResult), decodedPath);
-    }
-    const porcelainResult = await fn(porcelainPayload, options, shiftedNext);
-    let result;
-    if (porcelainResult === unchanged) {
-      result = nextResult;
-    } else {
-      result = common.encodeGraph(common.wrapObject(porcelainResult, decodedPath));
-      if (isRead && !nextCalled) {
-        const appliedQuery = common.wrap(common.unwrap(payload, path), path);
-        result = common.finalize(result, appliedQuery);
-        result = common.wrap(common.unwrap(result, path), path);
-      }
-      if (!nextCalled && remainingPayload.length) {
-        remainingNextResult = await next(remainingPayload);
-      }
-      if (remainingNextResult?.length) {
-        common.merge(result, remainingNextResult);
-      }
-    }
-    return result;
-  };
-}
-function shiftGen(fn, path) {
-  path = common.encodePath(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, nextOptions) {
-      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, nextOptions)) {
-        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 splitPath = (path) => Array.isArray(path) ? path : path === "" ? [] : String(path).split(".");
-function validateCall(...args) {
-  if (args.length === 1) {
-    return [[], args[0], {}];
-  }
-  if (args.length === 2) {
-    if (common.isPlainObject(args[0])) {
-      if (!common.isPlainObject(args[1])) {
-        throw Error(`validateCall.invalid_options: ${JSON.stringify(args[1])}`);
-      }
-      return [[], args[0], args[1]];
-    }
-    return [splitPath(args[0]), args[1], {}];
-  }
-  if (args.length === 3) {
-    if (!common.isPlainObject(args[2])) {
-      throw Error(`validateCall.invalid_options: ${JSON.stringify(args[1])}`);
-    }
-    return [splitPath(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]];
-  }
-  if (args.length === 2) {
-    if (typeof args[1] !== "function") {
-      throw Error(`validateOn.invalid_handler: ${JSON.stringify(args[1])}`);
-    }
-    return [splitPath(args[0]), args[1]];
-  }
-  throw Error(`validateOn.invalid_args: ${JSON.stringify(args)}`);
-}
-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, wrapProvider(handle, path, true));
-  }
-  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, () => {
-            throw Error(`porcelain.watch_next_unsupported: ${path}`);
-          });
-          (async () => {
-            try {
-              const 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, wrapProvider(handle, path, false));
-  }
-  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), 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), 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), path);
-  }
-}
-Graffy.unchanged = unchanged;
-module.exports = Graffy;

package/index.mjs

@@ -1,259 +0,0 @@
-import { encodePath, unwrap, unwrapObject, remove, encodeGraph, wrapObject, wrap, finalize, merge, mergeStreams, decodeGraph as decodeGraph$1, encodeQuery, decodeQuery as decodeQuery$1, isPlainObject, decorate } from "@graffy/common";
-import { makeStream, mapStream as mapStream$1 } from "@graffy/stream";
-import debug from "debug";
-const log = debug("graffy:core");
-function resolve(handlers, firstPayload, firstOptions) {
-  if (!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 (!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: encodePath(path), handle });
-  }
-  call(type, payload, options = {}) {
-    log("call", type, payload);
-    return resolve(this.handlers[type], payload, options);
-  }
-}
-async function mapStream(stream, fn) {
-  for await (const value of stream) {
-    fn(value);
-  }
-}
-const unchanged = /* @__PURE__ */ Symbol("Payload or result unchanged by handler");
-const decodeCache = /* @__PURE__ */ new WeakMap();
-function memoizeDecode(origDecode) {
-  return (payload) => {
-    if (decodeCache.has(payload)) return decodeCache.get(payload);
-    const decoded = origDecode(payload);
-    if (payload.type === "object" && payload) decodeCache.set(payload, decoded);
-    return decoded;
-  };
-}
-const decodeGraph = memoizeDecode(decodeGraph$1);
-const decodeQuery = memoizeDecode(decodeQuery$1);
-function wrapProvider(fn, decodedPath, isRead) {
-  const decodePayload = isRead ? decodeQuery : decodeGraph;
-  const encodePayload = isRead ? encodeQuery : encodeGraph;
-  const path = encodePath(decodedPath);
-  return async function wrappedProvider(payload, options, next) {
-    let nextCalled = false;
-    let nextResult;
-    let remainingNextResult;
-    const porcelainPayload = unwrapObject(decodePayload(payload), decodedPath);
-    const remainingPayload = remove(payload, path) || [];
-    async function shiftedNext(porcelainNextPayload, nextOptions) {
-      nextCalled = true;
-      let nextPayload;
-      if (porcelainNextPayload === unchanged) {
-        nextPayload = payload;
-      } else {
-        nextPayload = encodePayload(
-          wrapObject(porcelainNextPayload, decodedPath)
-        );
-        if (remainingPayload.length) merge(nextPayload, remainingPayload);
-      }
-      nextResult = await next(nextPayload, nextOptions);
-      remainingNextResult = remove(nextResult, path) || [];
-      return unwrapObject(decodeGraph(nextResult), decodedPath);
-    }
-    const porcelainResult = await fn(porcelainPayload, options, shiftedNext);
-    let result;
-    if (porcelainResult === unchanged) {
-      result = nextResult;
-    } else {
-      result = encodeGraph(wrapObject(porcelainResult, decodedPath));
-      if (isRead && !nextCalled) {
-        const appliedQuery = wrap(unwrap(payload, path), path);
-        result = finalize(result, appliedQuery);
-        result = wrap(unwrap(result, path), path);
-      }
-      if (!nextCalled && remainingPayload.length) {
-        remainingNextResult = await next(remainingPayload);
-      }
-      if (remainingNextResult?.length) {
-        merge(result, remainingNextResult);
-      }
-    }
-    return result;
-  };
-}
-function shiftGen(fn, path) {
-  path = encodePath(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, nextOptions) {
-      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, nextOptions)) {
-        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 splitPath = (path) => Array.isArray(path) ? path : path === "" ? [] : String(path).split(".");
-function validateCall(...args) {
-  if (args.length === 1) {
-    return [[], args[0], {}];
-  }
-  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]];
-    }
-    return [splitPath(args[0]), args[1], {}];
-  }
-  if (args.length === 3) {
-    if (!isPlainObject(args[2])) {
-      throw Error(`validateCall.invalid_options: ${JSON.stringify(args[1])}`);
-    }
-    return [splitPath(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]];
-  }
-  if (args.length === 2) {
-    if (typeof args[1] !== "function") {
-      throw Error(`validateOn.invalid_handler: ${JSON.stringify(args[1])}`);
-    }
-    return [splitPath(args[0]), args[1]];
-  }
-  throw Error(`validateOn.invalid_args: ${JSON.stringify(args)}`);
-}
-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, wrapProvider(handle, path, true));
-  }
-  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$1(query), options, () => {
-            throw Error(`porcelain.watch_next_unsupported: ${path}`);
-          });
-          (async () => {
-            try {
-              const 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, wrapProvider(handle, path, false));
-  }
-  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 = wrapObject(porcelainQuery, path);
-    const query = encodeQuery(rootQuery);
-    const result = await this.core.call("read", query, options || {});
-    return unwrapObject(decorate(result, rootQuery), 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), path)
-    );
-  }
-  async write(...args) {
-    const [path, porcelainChange, options] = validateCall(...args);
-    const change = encodeGraph(wrapObject(porcelainChange, path));
-    const writtenChange = await this.core.call("write", change, options || {});
-    return unwrapObject(decodeGraph$1(writtenChange), path);
-  }
-}
-Graffy.unchanged = unchanged;
-export {
-  Graffy as default
-};

package/types/shift.d.ts

@@ -1,3 +0,0 @@
-export function wrapProvider(fn: any, decodedPath: any, isRead: any): (payload: any, options: any, next: any) => Promise<any>;
-export function shiftGen(fn: any, path: any): (payload: any, options: any, next: any) => AsyncGenerator<any, void, any>;
-export const unchanged: unique symbol;

package/types/validate.d.ts

@@ -1,2 +0,0 @@
-export function validateCall(...args: any[]): any[];
-export function validateOn(...args: any[]): any[];

package/{types/index.d.ts → index.d.ts}

@@ -1,2 +1,2 @@
-export default Graffy;
 import Graffy from './Graffy.js';
+export default Graffy;