@graffy/link 0.15.25-alpha.4 → 0.15.25-alpha.5

package/package.json

@@ -2,13 +2,8 @@
   "name": "@graffy/link",
   "description": "Graffy module for constructing links using an intuitive, declarative notation.",
   "author": "aravind (https://github.com/aravindet)",
-  "version": "0.15.25-alpha.4",
-  "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,7 +11,7 @@
   },
   "license": "Apache-2.0",
   "dependencies": {
-    "@graffy/common": "0.15.25-alpha.4",
+    "@graffy/common": "0.15.25-alpha.5",
     "debug": "^4.3.3"
   }
 }

package/index.cjs

@@ -1,325 +0,0 @@
-"use strict";
-const common = require("@graffy/common");
-const debug = require("debug");
-const _interopDefaultLegacy = (e) => e && typeof e === "object" && "default" in e ? e : { default: e };
-const debug__default = /* @__PURE__ */ _interopDefaultLegacy(debug);
-function linkGraph(rootGraph, defs) {
-  let version = rootGraph[0].version;
-  for (const { path, def } of defs) {
-    const braid = def.map(getChoices);
-    const strands = unbraid(braid);
-    for (const { value, vars } of strands) {
-      const realPath = makeRef(path, vars);
-      const realRef = makeRef(value, vars);
-      const node = { key: realPath.pop(), path: common.encodePath(realRef), version };
-      const [range] = common.splitRef(realRef);
-      if (range)
-        node.prefix = true;
-      let target = rootGraph;
-      do {
-        const key = realPath.shift();
-        const nextTarget = target[common.findFirst(target, key)];
-        if (!nextTarget || nextTarget.key !== key || nextTarget.end) {
-          realPath.unshift(key);
-          break;
-        }
-        target = nextTarget.path ? common.unwrap(rootGraph, nextTarget.path) : nextTarget.children;
-      } while (target && realPath.length);
-      if (!target)
-        return;
-      common.merge(target, realPath.length ? common.wrap([node], realPath, version) : [node]);
-    }
-  }
-  return rootGraph;
-  function getChoices(key) {
-    if (typeof key === "string" && key[0] === "$" && key[1] === "$") {
-      return lookupValues(rootGraph, key.slice(2).split("."));
-    }
-    if (Array.isArray(key)) {
-      if (!key.length)
-        return [{ value: [], vars: {} }];
-      return unbraid(key.map(getChoices));
-    }
-    if (typeof key === "object" && key) {
-      const [range = {}, filter = {}] = common.splitArgs(key);
-      const entries = Object.entries(filter).flat();
-      if (!entries.length)
-        return [{ value: {}, vars: {} }];
-      const strands = unbraid(entries.map(getChoices));
-      return strands.map(({ value, vars }) => ({
-        value: {
-          ...range,
-          ...Object.fromEntries(
-            value.reduce((acc, item, i) => {
-              if (i % 2) {
-                acc[acc.length - 1].push(item);
-              } else {
-                acc.push([item]);
-              }
-              return acc;
-            }, [])
-          )
-        },
-        vars
-      }));
-    }
-    return [{ value: key, vars: {} }];
-  }
-  function lookupValues(graph, path, vars = {}) {
-    const [key, ...rest] = path;
-    if (key[0] === "$") {
-      return graph.flatMap((node2) => {
-        if (node2.end)
-          return [];
-        const newVars = { ...vars, [key.slice(1)]: node2.key };
-        return recurse(node2, rest, newVars);
-      });
-    }
-    let node = graph[common.findFirst(graph, key)];
-    if (!node || node.key !== key || node.end)
-      return [];
-    return recurse(node, rest, vars);
-  }
-  function recurse(node, path, vars) {
-    if (!path.length)
-      return [{ value: node.value, vars }];
-    if (node.children)
-      return lookupValues(node.children, path, vars);
-    if (node.path) {
-      const linked = common.unwrap(rootGraph, node.path);
-      if (Array.isArray(linked))
-        return lookupValues(linked, path, vars);
-    }
-    throw Error("link.no_children " + JSON.stringify(node));
-  }
-}
-function unbraid(braid) {
-  if (!braid.length)
-    return [];
-  const [options, ...rest] = braid;
-  if (!rest.length) {
-    return options.map((option) => ({
-      value: [option.value],
-      vars: option.vars
-    }));
-  }
-  const strands = unbraid(rest);
-  return options.flatMap(
-    (option) => strands.filter((strand) => isCompatible(option.vars, strand.vars)).map((strand) => ({
-      value: [option.value, ...strand.value],
-      vars: { ...option.vars, ...strand.vars }
-    }))
-  );
-}
-function isCompatible(oVars, sVars) {
-  for (const name in oVars) {
-    if (name in sVars && oVars[name] !== sVars[name])
-      return false;
-  }
-  return true;
-}
-function makeRef(def, vars) {
-  function getValue(key) {
-    if (typeof key !== "string")
-      return key;
-    return key[0] === "$" && key.slice(1) in vars ? vars[key.slice(1)] : key;
-  }
-  function replacePlaceholders(key) {
-    if (Array.isArray(key)) {
-      return key.map(replacePlaceholders);
-    }
-    if (typeof key === "object" && key) {
-      const result = {};
-      for (const prop in key) {
-        result[replacePlaceholders(prop)] = replacePlaceholders(key[prop]);
-      }
-      return result;
-    }
-    return getValue(key);
-  }
-  const ref = def.map(replacePlaceholders);
-  return ref;
-}
-function prepQueryLinks(rootQuery, defs) {
-  return defs.flatMap(({ path, def }) => prepQueryDef(rootQuery, path, def));
-  function prepQueryDef(query, path, def, vars = {}, version = 0) {
-    var _a;
-    function addDefQuery(subQuery) {
-      common.add(rootQuery, getDefQuery(def, vars, version));
-      const [range, filter] = common.splitRef(def);
-      if (range && subQuery.length) {
-        return subQuery.map((node) => {
-          if (!node.prefix && !node.end) {
-            throw Error(
-              "link.range_expected: " + path.concat(node.key).join(".")
-            );
-          }
-          return {
-            path: path.concat(node.key),
-            def: prepareDef(
-              def.slice(0, -1).concat({
-                ...filter,
-                ...node.prefix ? common.decodeArgs(node) : {},
-                ...range
-              }),
-              vars
-            )
-          };
-        });
-      } else {
-        return [{ path, def: prepareDef(def, vars) }];
-      }
-    }
-    function prefixKey(defs2, key2) {
-      return defs2.map(({ path: path2, def: def2 }) => ({
-        path: [key2, ...path2],
-        def: def2
-      }));
-    }
-    function makePager(pager) {
-      Object.defineProperty(pager, "toString", { value: () => key });
-      return pager;
-    }
-    if (!Array.isArray(query) || !query.length)
-      return [];
-    const [key, ...rest] = path;
-    if (rest.length === 0) {
-      if (key[0] === "$") {
-        return query.splice(0).flatMap((node) => {
-          vars[key.slice(1)] = makePager(common.decodeArgs(node));
-          return addDefQuery(node.children);
-        });
-      } else {
-        const ix = common.findFirst(query, key);
-        if (((_a = query[ix]) == null ? void 0 : _a.key) !== key)
-          return [];
-        const [{ children: subQuery }] = query.splice(ix, 1);
-        return addDefQuery(subQuery);
-      }
-    }
-    let used = [];
-    if (key[0] === "$") {
-      for (const node of query) {
-        if (!common.isBranch(node))
-          continue;
-        let usedHere;
-        if (node.prefix) {
-          usedHere = node.children.flatMap((subNode) => {
-            const pager = makePager(common.decodeArgs(subNode));
-            return prefixKey(
-              prepQueryDef(
-                subNode.children,
-                rest,
-                def,
-                { ...vars, [key.slice(1)]: [node.key, pager] },
-                node.version
-              ),
-              key
-            );
-          });
-        } else {
-          usedHere = prepQueryDef(
-            node.children,
-            rest,
-            def,
-            { ...vars, [key.slice(1)]: node.key },
-            node.version
-          );
-        }
-        usedHere = prefixKey(usedHere, node.key);
-        used = used.concat(usedHere);
-      }
-    } else {
-      const node = query[common.findFirst(query, key)];
-      if (!node || node.key !== key || !node.children)
-        return [];
-      used = prepQueryDef(node.children, rest, def, vars, node.version);
-      used = prefixKey(used, node.key);
-    }
-    for (let i = 0; i < query.length; i++) {
-      if (query[i].children && query[i].children.length === 0) {
-        query.splice(i, 1);
-        i--;
-      }
-    }
-    return used;
-  }
-}
-function getDefQuery(def, vars, version) {
-  function getValue(key) {
-    return key[0] === "$" ? vars[key.slice(1)] : key;
-  }
-  function getPath(template) {
-    return template.split(".").flatMap(getValue);
-  }
-  const defQuery = [];
-  function addDefQueries(key) {
-    if (typeof key === "string" && key[0] === "$" && key[1] === "$") {
-      common.add(defQuery, common.wrapValue(1, getPath(key.slice(2)), version));
-    }
-    if (Array.isArray(key)) {
-      key.map(addDefQueries);
-    }
-    if (typeof key === "object" && key) {
-      for (const prop in key) {
-        addDefQueries(prop);
-        addDefQueries(key[prop]);
-      }
-    }
-  }
-  def.map(addDefQueries);
-  return defQuery;
-}
-function prepareDef(def, vars) {
-  function getValue(key) {
-    if (typeof key !== "string")
-      return key;
-    return key[0] === "$" && key.slice(1) in vars ? vars[key.slice(1)] : key;
-  }
-  function replacePlaceholders(key) {
-    if (typeof key === "string" && key[0] === "$" && key[1] === "$") {
-      return "$$" + key.slice(2).split(".").flatMap(getValue).join(".");
-    }
-    if (Array.isArray(key)) {
-      return key.map(replacePlaceholders);
-    }
-    if (typeof key === "object" && key) {
-      const result = {};
-      for (const prop in key) {
-        result[replacePlaceholders(prop)] = replacePlaceholders(key[prop]);
-      }
-      return result;
-    }
-    return getValue(key);
-  }
-  const ref = def.map(replacePlaceholders);
-  return ref;
-}
-const log = debug__default.default("graffy:link");
-const index = (defs) => (store) => {
-  const prefix = store.path;
-  const defEntries = Object.entries(defs).map(([prop, def]) => ({
-    path: prop.split("."),
-    def
-  }));
-  store.on("read", async (query, options, next) => {
-    const unwrappedQuery = clone(common.unwrap(query, prefix));
-    const usedDefs = prepQueryLinks(unwrappedQuery, defEntries);
-    if (!usedDefs.length)
-      return next(query, options);
-    const result = await next(common.wrap(unwrappedQuery, prefix), options);
-    const version = result[0].version;
-    const unwrappedResult = common.unwrap(result, prefix);
-    common.add(unwrappedQuery, common.unwrap(query, prefix));
-    log("finalizing", prefix, unwrappedQuery);
-    const finalizedResult = common.finalize(unwrappedResult, unwrappedQuery, version);
-    log("beforeAddingLinks", prefix, finalizedResult);
-    linkGraph(finalizedResult, usedDefs);
-    log("afterAddingLinks", prefix, finalizedResult);
-    return common.wrap(finalizedResult, prefix, version);
-  });
-};
-function clone(tree) {
-  return JSON.parse(JSON.stringify(tree));
-}
-module.exports = index;