@tanstack/db/dist/cjs/query/live/public-key-reduction.cjs

A reactive client store for building super fast apps on sync

"use strict";
Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
const dbIvm = require("@tanstack/db-ivm");
const utils = require("../../utils.cjs");
const equalityValueIdentity = require("../equality-value-identity.cjs");
const routeMetadata = require("../compiler/route-metadata.cjs");
const errorMessage = require("../../error-message.cjs");
function exposeRouting(pipeline) {
  return pipeline.pipe(
    dbIvm.map(([key, rawTuple]) => {
      const tuple = rawTuple;
      return [
        key,
        [
          tuple[0],
          tuple[1],
          tuple[2],
          tuple[3],
          tuple[0][routeMetadata.INCLUDES_ROUTING],
          tuple[4]
        ]
      ];
    })
  );
}
function canonicalizeByPublicKey(pipeline, getKey, scope, valueIdentity) {
  return pipeline.pipe(
    dbIvm.map(([internalKey, rawTuple]) => {
      const tuple = rawTuple;
      const publicKey = getKey ? getKey(tuple[0]) : tuple[5] ?? internalKey;
      const relationKey = scope === `root` ? dbIvm.serializeValue([`root`, publicKey]) : dbIvm.serializeValue([
        routeKey(tuple[2], tuple[3], valueIdentity),
        publicKey
      ]);
      return [relationKey, { publicKey, tuple }];
    }),
    dbIvm.reduce((values) => {
      const totalMultiplicity = values.reduce(
        (total, [, multiplicity]) => total + multiplicity,
        0
      );
      if (totalMultiplicity === 0) return [];
      if (totalMultiplicity < 0) {
        throw new Error(
          errorMessage.devBuild() && process.env.NODE_ENV !== `production` ? `Canonical query row has negative multiplicity` : errorMessage.codedMessage(154)
        );
      }
      const visible = values.find(([, multiplicity]) => multiplicity > 0)?.[0];
      if (!visible) {
        throw new Error(
          errorMessage.devBuild() && process.env.NODE_ENV !== `production` ? `Canonical query row has no positive contributor` : errorMessage.codedMessage(155)
        );
      }
      for (const [candidate, multiplicity] of values) {
        if (multiplicity <= 0) continue;
        assertCongruentContributors(visible, candidate);
      }
      return [[visible, 1]];
    }),
    dbIvm.map(([relationKey, { publicKey, tuple }]) => [
      scope === `root` ? publicKey : relationKey,
      tuple
    ])
  );
}
function assertCongruentContributors(left, right) {
  const [leftValue, leftOrder, leftCorrelation, leftContext, leftRouting] = left.tuple;
  const [rightValue, rightOrder, rightCorrelation, rightContext, rightRouting] = right.tuple;
  if (leftOrder !== rightOrder || !utils.deepEquals(leftValue, rightValue) || !utils.deepEquals(leftCorrelation, rightCorrelation) || !utils.deepEquals(leftContext, rightContext) || !utils.deepEquals(leftRouting, rightRouting)) {
    throw new Error(
      errorMessage.devBuild() && process.env.NODE_ENV !== `production` ? `Query contributors for public key ${dbIvm.serializeValue(left.publicKey)} are not congruent` : errorMessage.codedMessage(156, { publicKey: left.publicKey })
    );
  }
}
function routeKey(correlationKey, parentContext, valueIdentity) {
  return dbIvm.serializeValue([
    valueIdentity.equality(correlationKey ?? null),
    equalityValueIdentity.getParentContextIdentity(parentContext ?? null)
  ]);
}
function reducePublicKeys(compilation, getKey) {
  return {
    pipeline: canonicalizeByPublicKey(
      exposeRouting(compilation.pipeline),
      getKey,
      `root`,
      compilation.valueIdentity
    ),
    facades: void 0
  };
}
exports.canonicalizeByPublicKey = canonicalizeByPublicKey;
exports.exposeRouting = exposeRouting;
exports.reducePublicKeys = reducePublicKeys;
exports.routeKey = routeKey;
//# sourceMappingURL=public-key-reduction.cjs.map