@gakim-digital/dexter-bridge 0.12.2 → 0.13.1

package/src/framerBehaviorContract.js

@@ -1,229 +0,0 @@
-// Dexter does not model Framer's interaction features. The model decides how
-// to build a behavior from Framer's own documentation; this module only checks
-// that the properties the model says carry the behavior exist on the live
-// nodes it names.
-
-const MAX_SEARCH_DEPTH = 6;
-const MAX_OBSERVED_CHARS = 1000;
-
-function isRecord(value) {
-  return Boolean(value && typeof value === 'object' && !Array.isArray(value));
-}
-
-function text(value, maximum = 500) {
-  return typeof value === 'string'
-    ? value.trim().slice(0, maximum)
-    : '';
-}
-
-function uniqueStrings(values, maximum = 50) {
-  return Array.from(new Set(
-    (Array.isArray(values) ? values : [])
-      .map((value) => text(value, 500))
-      .filter(Boolean),
-  )).slice(0, maximum);
-}
-
-function contractError(code, message) {
-  return Object.assign(new Error(message), { code, statusCode: 400 });
-}
-
-function normalizeBehavior(rawBehavior, index) {
-  const id = text(rawBehavior?.id, 120);
-  const description = text(rawBehavior?.description, 500);
-  if (!isRecord(rawBehavior) || !id || description.length < 5) {
-    throw contractError(
-      'FRAMER_BEHAVIOR_CONTRACT_INVALID',
-      `Behavior ${index + 1} needs an id and a description of what the user should experience.`,
-    );
-  }
-  return {
-    id,
-    description,
-    targetNodeIds: uniqueStrings(rawBehavior.targetNodeIds, 50),
-  };
-}
-
-export function normalizeBehaviorPlan(rawArguments) {
-  const behaviors = (Array.isArray(rawArguments?.behaviors)
-    ? rawArguments.behaviors
-    : []).slice(0, 20).map(normalizeBehavior);
-  const ids = new Set();
-  for (const behavior of behaviors) {
-    if (ids.has(behavior.id)) {
-      throw contractError(
-        'FRAMER_BEHAVIOR_CONTRACT_INVALID',
-        `Behavior IDs must be unique; "${behavior.id}" is duplicated.`,
-      );
-    }
-    ids.add(behavior.id);
-  }
-  return { behaviors };
-}
-
-export function mergeBehaviorPlans(current, next) {
-  if (!current) return next;
-  const byId = new Map(current.behaviors.map((item) => [item.id, item]));
-  next.behaviors.forEach((item) => byId.set(item.id, item));
-  return { behaviors: [...byId.values()] };
-}
-
-export function normalizeBehaviorEvidence(rawChecks, plan) {
-  const behaviorIds = new Set((plan?.behaviors || []).map((item) => item.id));
-  const checks = (Array.isArray(rawChecks) ? rawChecks : []).slice(0, 50);
-  if (!checks.length) {
-    throw contractError(
-      'FRAMER_BEHAVIOR_EVIDENCE_REQUIRED',
-      'Name at least one node and the Framer property that carries a planned behavior.',
-    );
-  }
-  return checks.map((raw, index) => {
-    const behaviorId = text(raw?.behaviorId, 120);
-    const nodeId = text(raw?.nodeId, 200);
-    const property = text(raw?.property, 120);
-    if (!isRecord(raw) || !behaviorIds.has(behaviorId) || !nodeId || !property) {
-      throw contractError(
-        'FRAMER_BEHAVIOR_EVIDENCE_INVALID',
-        `Check ${index + 1} must reference a planned behavior (${[...behaviorIds].join(', ') || 'none planned'}), a node ID, and the Framer property to inspect.`,
-      );
-    }
-    return {
-      behaviorId,
-      nodeId,
-      property,
-      contains: text(raw.contains, 500),
-    };
-  });
-}
-
-export function evidenceNodeIds(checks) {
-  return uniqueStrings(checks.map((check) => check.nodeId), 200);
-}
-
-function hasContent(value) {
-  if (value === undefined || value === null || value === '') return false;
-  if (Array.isArray(value)) return value.length > 0;
-  if (isRecord(value)) return Object.keys(value).length > 0;
-  return true;
-}
-
-// Finds the property on the node itself. Child nodes are skipped so a
-// descendant cannot satisfy a claim about its parent. A dotted name such as
-// `link.href` or `hoverEffect.opacity` reads the field inside the property's value.
-function propertyValues(node, property) {
-  const values = keyValues(node, property);
-  const [head, ...path] = property.split('.');
-  if (values.length > 0 || path.length === 0) return values;
-  return keyValues(node, head)
-    .map((value) => path.reduce(
-      (current, key) => (isRecord(current) ? current[key] : undefined),
-      value,
-    ))
-    .filter(hasContent);
-}
-
-function keyValues(node, property) {
-  const values = [];
-  const visit = (current, depth) => {
-    if (depth > MAX_SEARCH_DEPTH || values.length >= 10) return;
-    if (Array.isArray(current)) {
-      current.forEach((item) => visit(item, depth + 1));
-      return;
-    }
-    if (!isRecord(current)) return;
-    for (const [key, nested] of Object.entries(current)) {
-      if (key === 'children') continue;
-      if (key === property) {
-        if (hasContent(nested)) values.push(nested);
-      } else {
-        visit(nested, depth + 1);
-      }
-    }
-  };
-  visit(node, 0);
-  return values;
-}
-
-function serialized(value) {
-  try {
-    return JSON.stringify(value);
-  } catch {
-    return '';
-  }
-}
-
-export function verifyBehaviorChecks({ checks, nodes }) {
-  return checks.map((check) => {
-    const node = nodes instanceof Map ? nodes.get(check.nodeId) : nodes?.[check.nodeId];
-    if (!node) {
-      return { ...check, verdict: 'unknown', reason: `node ${check.nodeId} was not found` };
-    }
-    const values = propertyValues(node, check.property);
-    if (values.length === 0) {
-      return {
-        ...check,
-        verdict: 'unknown',
-        reason: `${check.property} is not set on ${check.nodeId}`,
-      };
-    }
-    const observed = serialized(values.length === 1 ? values[0] : values);
-    if (check.contains && !observed.toLowerCase().includes(check.contains.toLowerCase())) {
-      return {
-        ...check,
-        verdict: 'contradicted',
-        reason: `${check.property} on ${check.nodeId} does not contain ${check.contains}`,
-        observedValue: observed.slice(0, MAX_OBSERVED_CHARS),
-      };
-    }
-    return {
-      ...check,
-      verdict: 'verified',
-      observedValue: observed.slice(0, MAX_OBSERVED_CHARS),
-    };
-  });
-}
-
-// Summarizes the current check results for every planned behavior. A behavior
-// is verified once each of its declared target nodes has a verified check.
-// status: missing (a behavior or target was never checked), contradicted (a
-// property holds a different value), unverified (some properties could not be
-// found, so the behavior is unconfirmed), or verified.
-export function summarizeBehaviorVerification(plan, checkResults) {
-  const behaviors = (plan?.behaviors || []).map((behavior) => {
-    const results = checkResults.filter((result) => result.behaviorId === behavior.id);
-    const verifiedNodeIds = new Set(
-      results.filter((result) => result.verdict === 'verified').map((result) => result.nodeId),
-    );
-    const contradictions = results
-      .filter((result) => result.verdict === 'contradicted')
-      .map((result) => result.reason);
-    const checkedNodeIds = new Set(results.map((result) => result.nodeId));
-    const uncheckedTargets = behavior.targetNodeIds.filter((nodeId) => !checkedNodeIds.has(nodeId));
-    const unverifiedTargets = behavior.targetNodeIds.filter((nodeId) => !verifiedNodeIds.has(nodeId));
-    const covered = behavior.targetNodeIds.length > 0
-      ? unverifiedTargets.length === 0
-      : verifiedNodeIds.size > 0;
-    return {
-      behaviorId: behavior.id,
-      checked: results.length > 0 && uncheckedTargets.length === 0,
-      verdict: contradictions.length > 0 ? 'contradicted' : covered ? 'verified' : 'unknown',
-      verifiedTargets: verifiedNodeIds.size,
-      expectedTargets: behavior.targetNodeIds.length,
-      unverifiedTargets,
-      uncheckedTargets,
-      contradictions: uniqueStrings(contradictions, 20),
-      unknowns: uniqueStrings(
-        results.filter((result) => result.verdict === 'unknown').map((result) => result.reason),
-        20,
-      ),
-    };
-  });
-  const status = behaviors.some((behavior) => !behavior.checked)
-    ? 'missing'
-    : behaviors.some((behavior) => behavior.verdict === 'contradicted')
-      ? 'contradicted'
-      : behaviors.some((behavior) => behavior.verdict === 'unknown')
-        ? 'unverified'
-        : 'verified';
-  return { status, behaviors };
-}