@agent-native/core-corpus 0.218.0 → 0.219.0

package/corpus/templates/design/shared/motion-text-runtime-v1.fixture.txt

@@ -0,0 +1,221 @@
+(function (source) {
+  var animations = source.animations;
+  var playbackMode = source.playbackMode;
+  if (typeof window !== "undefined" && window.matchMedia && window.matchMedia("(prefers-reduced-motion: reduce)").matches) return;
+  if (!document || typeof document.querySelectorAll !== "function") throw new Error("Motion text runtime requires a document.");
+  var previewBridge = typeof window !== "undefined" && window.__designMotionPreviewBridge === true;
+  var previewAnimations = [];
+  var allTargets = Array.prototype.slice.call(document.querySelectorAll("[data-agent-native-node-id]"));
+  var paragraphTags = { blockquote: true, h1: true, h2: true, h3: true, h4: true, h5: true, h6: true, li: true, p: true };
+  function textTokens(value, kind) {
+    var Segmenter = typeof Intl !== "undefined" ? Intl.Segmenter : null;
+    if (kind === "character") {
+      var characters = Segmenter ? Array.from(new Segmenter(undefined, { granularity: "grapheme" }).segment(value), function (part) { return part.segment; }) : Array.from(value);
+      return characters.map(function (part) { return { value: part, animated: !/^\s+$/u.test(part) }; });
+    }
+    var chunks;
+    if (Segmenter) {
+      chunks = Array.from(new Segmenter(undefined, { granularity: "word" }).segment(value), function (part) { return { value: part.segment, word: !!part.isWordLike }; });
+    } else {
+      chunks = (value.match(/\s+|[^\s]+/gu) || []).map(function (part) { return { value: part, word: !/^\s+$/u.test(part) }; });
+    }
+    var tokens = [];
+    for (var index = 0; index < chunks.length; index += 1) {
+      var chunk = chunks[index];
+      if (/^\s+$/u.test(chunk.value)) {
+        tokens.push({ value: chunk.value, animated: false });
+      } else if (chunk.word) {
+        tokens.push({ value: chunk.value, animated: true });
+      } else if (tokens.length && tokens[tokens.length - 1].animated) {
+        tokens[tokens.length - 1].value += chunk.value;
+      } else {
+        var nextWord = chunks.slice(index + 1).findIndex(function (candidate) { return candidate.word; });
+        if (nextWord >= 0) {
+          var punctuation = chunk.value;
+          while (index + 1 < chunks.length && !chunks[index + 1].word && !/^\s+$/u.test(chunks[index + 1].value)) punctuation += chunks[++index].value;
+          tokens.push({ value: punctuation, animated: true });
+        } else {
+          tokens.push({ value: chunk.value, animated: false });
+        }
+      }
+    }
+    return tokens;
+  }
+  function descendantTextNodes(target) {
+    var nodes = [];
+    function visit(node) {
+      if (node.nodeName === "#text") { nodes.push(node); return; }
+      Array.prototype.slice.call(node.childNodes || []).forEach(visit);
+    }
+    visit(target);
+    return nodes;
+  }
+  function nodeText(node) {
+    return typeof node.nodeValue === "string" ? node.nodeValue : (node.value || "");
+  }
+  function splitTextTarget(target, kind) {
+    var leaves = descendantTextNodes(target);
+    var value = leaves.map(nodeText).join("");
+    var tokens = textTokens(value, kind === "line" ? "word" : kind);
+    var units = [];
+    var sourceOffset = 0;
+    tokens.forEach(function (token) {
+      var start = sourceOffset;
+      var end = start + token.value.length;
+      sourceOffset = end;
+      if (token.animated) units.push({ start: start, end: end, index: units.length, fragments: [] });
+    });
+    if (units.length === 0) throw new Error("Motion text target has no animatable text units.");
+    if (units.length > 512) throw new Error("Motion text target exceeds the 512-unit runtime limit.");
+
+    var leafOffset = 0;
+    leaves.forEach(function (leaf) {
+      var text = nodeText(leaf);
+      var leafStart = leafOffset;
+      var leafEnd = leafStart + text.length;
+      leafOffset = leafEnd;
+      if (!text.length) return;
+
+      var fragment = document.createDocumentFragment();
+      var cursor = 0;
+      tokens.forEach(function (token) {
+        var tokenStart = cursor;
+        var tokenEnd = tokenStart + token.value.length;
+        cursor = tokenEnd;
+        var start = Math.max(leafStart, tokenStart);
+        var end = Math.min(leafEnd, tokenEnd);
+        if (start >= end) return;
+        var part = text.slice(start - leafStart, end - leafStart);
+        if (!token.animated) {
+          fragment.appendChild(document.createTextNode(part));
+          return;
+        }
+        var unitIndex = units.findIndex(function (unit) { return unit.start === tokenStart; });
+        var unit = units[unitIndex];
+        var span = document.createElement("span");
+        span.setAttribute("data-agent-native-motion-text-unit", String(unit.index));
+        span.style.display = "inline-block";
+        span.appendChild(document.createTextNode(part));
+        fragment.appendChild(span);
+        unit.fragments.push(span);
+      });
+      if (leaf.parentNode) leaf.parentNode.replaceChild(fragment, leaf);
+    });
+    return units;
+  }
+  function paragraphUnits(target) {
+    var tag = String(target.tagName || "").toLowerCase();
+    if (paragraphTags[tag]) return [target];
+    var children = Array.prototype.slice.call(target.children || []);
+    if (children.length && children.every(function (child) { return paragraphTags[String(child.tagName || "").toLowerCase()]; })) return children;
+    if (children.length) throw new Error("Paragraph Text animation found unsupported nested elements.");
+    return [target];
+  }
+  function lineGroups(units) {
+    var tops = [];
+    return units.map(function (unit, index) {
+      var top = unit.getBoundingClientRect().top;
+      var found = tops.findIndex(function (existing) { return Math.abs(existing - top) < 0.5; });
+      if (found < 0) { tops.push(top); found = tops.length - 1; }
+      return { unit: unit, index: found };
+    });
+  }
+  function springSample(bounce, settle, x) {
+    if (x <= 0) return 0;
+    var u = x / settle;
+    if (u >= 1) return 1;
+    var zeta = Math.min(1, Math.max(0.02, 1 - bounce));
+    var omega = Math.log(1 / 0.001) / zeta;
+    if (zeta >= 1) return 1 - Math.exp(-omega * u) * (1 + omega * u);
+    var omegaD = omega * Math.sqrt(1 - zeta * zeta);
+    var decay = Math.exp(-zeta * omega * u);
+    return 1 - decay * (Math.cos(omegaD * u) + ((zeta * omega) / omegaD) * Math.sin(omegaD * u));
+  }
+  function springToLinear(bounce, settle) {
+    var sampleCount = 16 + Math.round(bounce * 34);
+    var stops = [];
+    for (var index = 0; index <= sampleCount; index += 1) {
+      var value = index === sampleCount ? 1 : springSample(bounce, settle, index / sampleCount);
+      stops.push((Math.round(value * 10000) / 10000).toString());
+    }
+    return "linear(" + stops.join(", ") + ")";
+  }
+  function motionEaseForWebAnimations(ease, element) {
+    var resolved = ease;
+    var reference = /^var\(--an-motion-ease-([a-z0-9][a-z0-9-]{0,63})\)$/.exec(String(ease));
+    if (reference) {
+      var property = "--an-motion-ease-" + reference[1];
+      resolved = window.getComputedStyle(element).getPropertyValue(property).trim();
+      if (!resolved || /^var\(/i.test(resolved)) throw new Error("Motion easing variable " + property + " is not defined or does not resolve to a concrete easing.");
+    }
+    var normalized = String(resolved).trim();
+    if (normalized.toLowerCase() === "spring") return springToLinear(0.25, 1);
+    var spring = /^spring\(\s*([+-]?(?:\d+\.?\d*|\.\d+))\s*(?:,\s*([+-]?(?:\d+\.?\d*|\.\d+))\s*)?\)$/i.exec(normalized);
+    if (/^spring/i.test(normalized) && !spring) throw new Error("Motion text easing is not supported: " + normalized);
+    if (spring) return springToLinear(Number(spring[1]), Number(spring[2] || 1));
+    return resolved;
+  }
+  var targetGroups = [];
+  animations.forEach(function (animation) {
+    var group = targetGroups.find(function (candidate) { return candidate.targetNodeId === animation.targetNodeId; });
+    if (!group) { group = { targetNodeId: animation.targetNodeId, animations: [] }; targetGroups.push(group); }
+    group.animations.push(animation);
+  });
+  targetGroups.forEach(function (targetGroup) {
+    var animation = targetGroup.animations[0];
+    var matches = allTargets.filter(function (candidate) { return candidate.getAttribute("data-agent-native-node-id") === targetGroup.targetNodeId; });
+    if (matches.length !== 1) throw new Error("Motion text target " + targetGroup.targetNodeId + " resolved to " + matches.length + " elements.");
+    var target = matches[0];
+    var entries;
+    if (animation.unit === "paragraph") {
+      entries = paragraphUnits(target).map(function (unit, index) { return { unit: unit, index: index }; });
+    } else {
+      var units = splitTextTarget(target, animation.unit);
+      var fragments = units.reduce(function (all, unit) { return all.concat(unit.fragments); }, []);
+      entries = animation.unit === "line"
+        ? lineGroups(fragments)
+        : fragments.map(function (unit) { return { unit: unit, index: Number(unit.getAttribute("data-agent-native-motion-text-unit")) }; });
+    }
+    var groupCount = entries.reduce(function (count, entry) { return Math.max(count, entry.index + 1); }, 0);
+    if ((groupCount - 1) * animation.staggerMs > 120000) throw new Error("Motion text stagger exceeds the 120000ms runtime limit.");
+    targetGroup.animations.forEach(function (track) {
+      entries.forEach(function (entry) {
+        if (typeof entry.unit.animate !== "function") throw new Error("Motion text requires the Web Animations API.");
+        var delayIndex = track.direction === "reverse" ? groupCount - 1 - entry.index : entry.index;
+        var keyframes = track.keyframes.map(function (keyframe) {
+          var frame = { offset: keyframe.t, easing: motionEaseForWebAnimations(keyframe.ease || "ease", entry.unit) };
+          frame[track.property] = keyframe.value;
+          return frame;
+        });
+        var delay = track.delayMs + delayIndex * track.staggerMs;
+        var options = { duration: track.durationMs, delay: delay, fill: "both" };
+        if (!previewBridge && playbackMode !== "once") {
+          options.iterations = Infinity;
+          if (playbackMode === "ping-pong") options.direction = "alternate";
+        }
+        var runningAnimation = entry.unit.animate(keyframes, options);
+        if (previewBridge) {
+          runningAnimation.pause();
+          runningAnimation.currentTime = 0;
+          previewAnimations.push({ animation: runningAnimation, delay: delay, duration: track.durationMs });
+        }
+      });
+    });
+  });
+  if (previewBridge && typeof window.addEventListener === "function") {
+    window.addEventListener("message", function (event) {
+      if (event.source !== window.parent || !event.data || typeof event.data.type !== "string") return;
+      if (event.data.type === "motion-preview") {
+        var t = Number(event.data.t);
+        var timelineDuration = Number(event.data.durationMs);
+        if (!Number.isFinite(t) || !Number.isFinite(timelineDuration) || timelineDuration <= 0) return;
+        var timelineTime = Math.max(0, Math.min(1, t)) * timelineDuration;
+        previewAnimations.forEach(function (entry) {
+          entry.animation.currentTime = Math.max(0, Math.min(entry.duration, timelineTime - entry.delay));
+        });
+      } else if (event.data.type === "motion-preview-clear") {
+        previewAnimations.forEach(function (entry) { entry.animation.currentTime = 0; });
+      }
+    });
+  }
+})(__MOTION_TEXT_SOURCE__);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agent-native/core-corpus",
-  "version": "0.218.0",
+  "version": "0.219.0",
   "description": "Opt-in source corpus for Agent-Native Core source-search.",
   "homepage": "https://github.com/BuilderIO/agent-native#readme",
   "bugs": {