@pibbl/core 0.0.1

package/dist/lib/animation/definition.js

@@ -0,0 +1,605 @@
+import { withSignalWriteForbidden } from "../signals/graph.js";
+import { easing } from "./easing.js";
+import {
+  createSpringRecord,
+  resolveSpringStart,
+  sampleSpring
+} from "./spring.js";
+const definitionRecords = /* @__PURE__ */ new WeakMap();
+const seekableActivationRecords = /* @__PURE__ */ new WeakMap();
+let keyframeDefinitions = 0;
+let keyframeStorageArrayAllocations = 0;
+let keyframeSamples = 0;
+let keyframeSampleArrayAllocations = 0;
+let keyframeSampleDepth = 0;
+function animationDefinitionPerformanceSnapshot() {
+  return Object.freeze({
+    keyframeDefinitions,
+    keyframeStorageArrayAllocations,
+    keyframeSamples,
+    keyframeSampleArrayAllocations
+  });
+}
+function definitionLabel(debugName) {
+  return debugName === void 0 ? "Pibbl animation definition" : `Pibbl animation definition "${debugName}"`;
+}
+function assertDuration(duration, debugName) {
+  if (!Number.isFinite(duration) || duration < 0) {
+    throw new RangeError(`${definitionLabel(debugName)} duration must be finite and nonnegative.`);
+  }
+}
+function assertFiniteNumber(value, message) {
+  if (!Number.isFinite(value)) throw new RangeError(message);
+}
+const MUTATING_MAP_METHODS = /* @__PURE__ */ new Set(["set", "delete", "clear"]);
+const MUTATING_SET_METHODS = /* @__PURE__ */ new Set(["add", "delete", "clear"]);
+const MUTATING_DATE_METHODS = /* @__PURE__ */ new Set([
+  "setDate",
+  "setFullYear",
+  "setHours",
+  "setMilliseconds",
+  "setMinutes",
+  "setMonth",
+  "setSeconds",
+  "setTime",
+  "setUTCDate",
+  "setUTCFullYear",
+  "setUTCHours",
+  "setUTCMilliseconds",
+  "setUTCMinutes",
+  "setUTCMonth",
+  "setUTCSeconds",
+  "setYear"
+]);
+function immutableBuiltin(target, mutatingMethods) {
+  return new Proxy(target, {
+    get(current, key) {
+      if (mutatingMethods.has(key)) {
+        return () => {
+          throw new TypeError("Cannot mutate an animation definition snapshot.");
+        };
+      }
+      const member = Reflect.get(current, key, current);
+      return typeof member === "function" && key !== "constructor" ? member.bind(current) : member;
+    },
+    set() {
+      return false;
+    },
+    defineProperty() {
+      return false;
+    },
+    deleteProperty() {
+      return false;
+    }
+  });
+}
+function rememberIdentity(value, seen) {
+  seen.set(value, value);
+  return value;
+}
+function hasOwnProperties(value, allowed) {
+  return Reflect.ownKeys(value).some((key) => !allowed.has(key));
+}
+function hasOnlyDataProperties(value, allowed) {
+  return Reflect.ownKeys(value).every((key) => {
+    if (allowed.has(key)) return true;
+    const descriptor = Object.getOwnPropertyDescriptor(value, key);
+    return descriptor !== void 0 && "value" in descriptor;
+  });
+}
+const ARRAY_OWN_KEYS = /* @__PURE__ */ new Set(["length"]);
+const REGEXP_OWN_KEYS = /* @__PURE__ */ new Set(["lastIndex"]);
+const snapshotsRequiringIsolation = /* @__PURE__ */ new WeakSet();
+function requiresIsolation(value) {
+  return (typeof value === "object" && value !== null || typeof value === "function") && snapshotsRequiringIsolation.has(value);
+}
+function propagateIsolation(snapshot, value) {
+  if (requiresIsolation(value)) snapshotsRequiringIsolation.add(snapshot);
+}
+function isArrayIndex(key) {
+  return typeof key === "string" && /^(?:0|[1-9]\d*)$/u.test(key);
+}
+function cloneTypedArray(value, buffer) {
+  if (value instanceof DataView) {
+    if (buffer !== void 0) {
+      return new DataView(buffer, value.byteOffset, value.byteLength);
+    }
+    const bytes = value.buffer.slice(value.byteOffset, value.byteOffset + value.byteLength);
+    return new DataView(bytes);
+  }
+  const TypedArray = value.constructor;
+  return buffer === void 0 ? new TypedArray(value) : new TypedArray(
+    buffer,
+    value.byteOffset,
+    value.length
+  );
+}
+function snapshotAnimationValue(value, seen, isolateStoredValue = false) {
+  if (value === null || typeof value === "function" || typeof value !== "object") {
+    return value;
+  }
+  const existing = seen.get(value);
+  if (existing !== void 0) return existing;
+  if (isolateStoredValue && !requiresIsolation(value)) {
+    seen.set(value, value);
+    return value;
+  }
+  if (value instanceof Date) {
+    if (hasOwnProperties(value, /* @__PURE__ */ new Set())) return rememberIdentity(value, seen);
+    const snapshot2 = immutableBuiltin(new Date(value.getTime()), MUTATING_DATE_METHODS);
+    seen.set(value, snapshot2);
+    return snapshot2;
+  }
+  if (value instanceof Map) {
+    if (hasOwnProperties(value, /* @__PURE__ */ new Set())) return rememberIdentity(value, seen);
+    const target = /* @__PURE__ */ new Map();
+    const snapshot2 = immutableBuiltin(target, MUTATING_MAP_METHODS);
+    seen.set(value, snapshot2);
+    for (const [key, entry] of value) {
+      const keySnapshot = snapshotAnimationValue(key, seen, isolateStoredValue);
+      const entrySnapshot = snapshotAnimationValue(entry, seen, isolateStoredValue);
+      target.set(keySnapshot, entrySnapshot);
+      propagateIsolation(snapshot2, keySnapshot);
+      propagateIsolation(snapshot2, entrySnapshot);
+    }
+    return snapshot2;
+  }
+  if (value instanceof Set) {
+    if (hasOwnProperties(value, /* @__PURE__ */ new Set())) return rememberIdentity(value, seen);
+    const target = /* @__PURE__ */ new Set();
+    const snapshot2 = immutableBuiltin(target, MUTATING_SET_METHODS);
+    seen.set(value, snapshot2);
+    for (const entry of value) {
+      const entrySnapshot = snapshotAnimationValue(entry, seen, isolateStoredValue);
+      target.add(entrySnapshot);
+      propagateIsolation(snapshot2, entrySnapshot);
+    }
+    return snapshot2;
+  }
+  if (Array.isArray(value)) {
+    const ownKeys = Reflect.ownKeys(value);
+    if (Object.getPrototypeOf(value) !== Array.prototype || ownKeys.some((key) => !ARRAY_OWN_KEYS.has(key) && !isArrayIndex(key)) || !hasOnlyDataProperties(value, ARRAY_OWN_KEYS)) {
+      return rememberIdentity(value, seen);
+    }
+    const snapshot2 = new Array(value.length);
+    if (keyframeSampleDepth > 0) keyframeSampleArrayAllocations++;
+    seen.set(value, snapshot2);
+    for (const key of ownKeys) {
+      if (ARRAY_OWN_KEYS.has(key)) continue;
+      const descriptor = Object.getOwnPropertyDescriptor(value, key);
+      if (descriptor === void 0 || !("value" in descriptor)) continue;
+      const itemSnapshot = snapshotAnimationValue(
+        descriptor.value,
+        seen,
+        isolateStoredValue
+      );
+      Object.defineProperty(snapshot2, key, {
+        configurable: false,
+        enumerable: descriptor.enumerable,
+        writable: false,
+        value: itemSnapshot
+      });
+      propagateIsolation(snapshot2, itemSnapshot);
+    }
+    return Object.freeze(snapshot2);
+  }
+  if (value instanceof RegExp) {
+    if (hasOwnProperties(value, REGEXP_OWN_KEYS)) return rememberIdentity(value, seen);
+    const snapshot2 = new RegExp(value.source, value.flags);
+    snapshot2.lastIndex = value.lastIndex;
+    seen.set(value, snapshot2);
+    snapshotsRequiringIsolation.add(snapshot2);
+    return snapshot2;
+  }
+  if (ArrayBuffer.isView(value)) {
+    const ownKeys = Reflect.ownKeys(value);
+    if (ownKeys.some((key) => !isArrayIndex(key))) return rememberIdentity(value, seen);
+    const buffer = value.buffer instanceof ArrayBuffer ? snapshotAnimationValue(value.buffer, seen, isolateStoredValue) : void 0;
+    const snapshot2 = cloneTypedArray(value, buffer);
+    seen.set(value, snapshot2);
+    snapshotsRequiringIsolation.add(snapshot2);
+    return snapshot2;
+  }
+  if (value instanceof ArrayBuffer) {
+    const snapshot2 = value.slice(0);
+    seen.set(value, snapshot2);
+    snapshotsRequiringIsolation.add(snapshot2);
+    return snapshot2;
+  }
+  const prototype = Object.getPrototypeOf(value);
+  if (prototype !== Object.prototype && prototype !== null || !hasOnlyDataProperties(value, /* @__PURE__ */ new Set())) {
+    return rememberIdentity(value, seen);
+  }
+  const snapshot = Object.create(prototype);
+  seen.set(value, snapshot);
+  for (const key of Reflect.ownKeys(value)) {
+    const descriptor = Object.getOwnPropertyDescriptor(value, key);
+    if (descriptor === void 0) continue;
+    const propertySnapshot = snapshotAnimationValue(
+      descriptor.value,
+      seen,
+      isolateStoredValue
+    );
+    Object.defineProperty(snapshot, key, {
+      configurable: false,
+      enumerable: descriptor.enumerable,
+      writable: false,
+      value: propertySnapshot
+    });
+    propagateIsolation(snapshot, propertySnapshot);
+  }
+  return Object.freeze(snapshot);
+}
+function isolateStoredAnimationValue(value, seen) {
+  return snapshotAnimationValue(value, seen, true);
+}
+function snapshotAnimationActivationValue(value, seen = /* @__PURE__ */ new WeakMap()) {
+  return snapshotAnimationValue(value, seen);
+}
+function validateSampledValue(sampled, debugName) {
+  if (typeof sampled === "number" && !Number.isFinite(sampled)) {
+    throw new RangeError(`${definitionLabel(debugName)} sampled value must be finite.`);
+  }
+  return sampled;
+}
+function createDefinition(record) {
+  const definition = Object.freeze({});
+  definitionRecords.set(
+    definition,
+    Object.freeze(record)
+  );
+  return definition;
+}
+function hasOwn(object, key) {
+  return Object.prototype.hasOwnProperty.call(object, key);
+}
+function callback(debugName, callback2) {
+  return withSignalWriteForbidden(
+    `${definitionLabel(debugName)} callbacks cannot write to signals.`,
+    callback2
+  );
+}
+function sampledProgress(duration, localTime) {
+  assertFiniteNumber(localTime, "Pibbl animation sample localTime must be finite.");
+  if (duration === 0) return Object.freeze({ localTime: 0, progress: 1 });
+  const normalizedLocalTime = Math.min(duration, Math.max(0, localTime));
+  return Object.freeze({
+    localTime: normalizedLocalTime,
+    progress: normalizedLocalTime / duration
+  });
+}
+function interpolate(from, to, progress, custom, debugName) {
+  if (custom === void 0 && (typeof from !== "number" || typeof to !== "number")) {
+    throw new TypeError(`${definitionLabel(debugName)} requires an explicit interpolator for nonnumeric values.`);
+  }
+  let sampled;
+  if (custom === void 0) {
+    sampled = from + (to - from) * progress;
+  } else {
+    const isolated = /* @__PURE__ */ new WeakMap();
+    const isolatedFrom = isolateStoredAnimationValue(from, isolated);
+    const isolatedTo = isolateStoredAnimationValue(to, isolated);
+    sampled = callback(debugName, () => custom(isolatedFrom, isolatedTo, progress));
+  }
+  return validateSampledValue(sampled, debugName);
+}
+function easedProgress(ease, progress, debugName) {
+  const eased = callback(debugName, () => ease(progress));
+  if (!Number.isFinite(eased)) {
+    throw new RangeError(`${definitionLabel(debugName)} easing result must be finite.`);
+  }
+  return eased;
+}
+function normalizeOffsets(values, offsets, debugName) {
+  if (offsets === void 0) {
+    return Object.freeze(values.map((_, index) => index / (values.length - 1)));
+  }
+  if (offsets.length !== values.length) {
+    throw new RangeError(`${definitionLabel(debugName)} keyframe offsets must match the values length.`);
+  }
+  const snapshot = [...offsets];
+  for (const offset of snapshot) {
+    if (!Number.isFinite(offset) || offset < 0 || offset > 1) {
+      throw new RangeError(`${definitionLabel(debugName)} keyframe offsets must be finite values within [0, 1].`);
+    }
+  }
+  if (snapshot[0] !== 0) {
+    throw new RangeError(`${definitionLabel(debugName)} keyframe offsets must start at 0.`);
+  }
+  if (snapshot.at(-1) !== 1) {
+    throw new RangeError(`${definitionLabel(debugName)} keyframe offsets must end at 1.`);
+  }
+  for (let index = 1; index < snapshot.length; index++) {
+    if (snapshot[index] < snapshot[index - 1]) {
+      throw new RangeError(`${definitionLabel(debugName)} keyframe offsets must be nondecreasing.`);
+    }
+  }
+  return Object.freeze(snapshot);
+}
+function normalizeEasings(easingOption, segmentCount, debugName) {
+  if (Array.isArray(easingOption)) {
+    if (easingOption.length !== segmentCount) {
+      throw new RangeError(`${definitionLabel(debugName)} keyframe easing list must have one entry per segment.`);
+    }
+    if (easingOption.some((ease2) => typeof ease2 !== "function")) {
+      throw new TypeError(`${definitionLabel(debugName)} keyframe easings must be functions.`);
+    }
+    return Object.freeze([...easingOption]);
+  }
+  const ease = easingOption ?? easing.linear;
+  if (typeof ease !== "function") {
+    throw new TypeError(`${definitionLabel(debugName)} easing must be a function.`);
+  }
+  return Object.freeze(Array.from({ length: segmentCount }, () => ease));
+}
+function tween(options) {
+  assertDuration(options.duration, options.debugName);
+  if (typeof options.easing !== "undefined" && typeof options.easing !== "function") {
+    throw new TypeError(`${definitionLabel(options.debugName)} easing must be a function.`);
+  }
+  if (typeof options.interpolate !== "undefined" && typeof options.interpolate !== "function") {
+    throw new TypeError(`${definitionLabel(options.debugName)} interpolator must be a function.`);
+  }
+  const hasFrom = hasOwn(options, "from");
+  const snapshots = /* @__PURE__ */ new WeakMap();
+  return createDefinition({
+    kind: "tween",
+    duration: options.duration,
+    debugName: options.debugName,
+    hasFrom,
+    from: hasFrom ? snapshotAnimationValue(options.from, snapshots) : void 0,
+    to: snapshotAnimationValue(options.to, snapshots),
+    easing: options.easing ?? easing.linear,
+    interpolate: options.interpolate
+  });
+}
+function keyframes(options) {
+  assertDuration(options.duration, options.debugName);
+  if (options.values.length < 2) {
+    throw new RangeError(`${definitionLabel(options.debugName)} keyframes require at least two values.`);
+  }
+  if (typeof options.interpolate !== "undefined" && typeof options.interpolate !== "function") {
+    throw new TypeError(`${definitionLabel(options.debugName)} interpolator must be a function.`);
+  }
+  const snapshots = /* @__PURE__ */ new WeakMap();
+  const values = Object.freeze(options.values.map((value) => snapshotAnimationValue(value, snapshots)));
+  const offsets = normalizeOffsets(values, options.offsets, options.debugName);
+  const easings = normalizeEasings(options.easing, values.length - 1, options.debugName);
+  keyframeDefinitions++;
+  keyframeStorageArrayAllocations += 3;
+  return createDefinition({
+    kind: "keyframes",
+    duration: options.duration,
+    debugName: options.debugName,
+    values,
+    offsets,
+    easings,
+    interpolate: options.interpolate
+  });
+}
+function spring(options) {
+  return createDefinition(createSpringRecord(options));
+}
+function defineAnimation(options) {
+  assertDuration(options.duration, options.debugName);
+  if (typeof options.sample !== "function") {
+    throw new TypeError(`${definitionLabel(options.debugName)} sample must be a function.`);
+  }
+  return createDefinition({
+    kind: "custom",
+    duration: options.duration,
+    debugName: options.debugName,
+    sample: options.sample
+  });
+}
+function stepper(options) {
+  if (typeof options.initial !== "function") {
+    throw new TypeError(`${definitionLabel(options.debugName)} stepper initial must be a function.`);
+  }
+  if (typeof options.step !== "function") {
+    throw new TypeError(`${definitionLabel(options.debugName)} stepper step must be a function.`);
+  }
+  if (typeof options.read !== "function") {
+    throw new TypeError(`${definitionLabel(options.debugName)} stepper read must be a function.`);
+  }
+  if (typeof options.done !== "undefined" && typeof options.done !== "function") {
+    throw new TypeError(`${definitionLabel(options.debugName)} stepper done must be a function.`);
+  }
+  if (!Number.isFinite(options.stepMilliseconds) || options.stepMilliseconds <= 0) {
+    throw new RangeError(`${definitionLabel(options.debugName)} stepper stepMilliseconds must be finite and positive.`);
+  }
+  const maxElapsedMilliseconds = options.maxElapsedMilliseconds ?? 100;
+  if (!Number.isFinite(maxElapsedMilliseconds) || maxElapsedMilliseconds <= 0) {
+    throw new RangeError(`${definitionLabel(options.debugName)} stepper maxElapsedMilliseconds must be finite and positive.`);
+  }
+  return createDefinition({
+    kind: "stepper",
+    duration: Number.POSITIVE_INFINITY,
+    debugName: options.debugName,
+    stepMilliseconds: options.stepMilliseconds,
+    maxElapsedMilliseconds,
+    initial: options.initial,
+    step: options.step,
+    read: options.read,
+    done: options.done
+  });
+}
+function getDefinitionRecord(definition) {
+  const record = definitionRecords.get(definition);
+  if (record === void 0) throw new TypeError("Expected a Pibbl animation definition.");
+  return record;
+}
+function sampleSeekableDefinition(definition, input) {
+  const record = getDefinitionRecord(definition);
+  if (record.kind === "stepper") {
+    throw new TypeError(
+      `${definitionLabel(record.debugName)} is stateful and requires the stateful program evaluator.`
+    );
+  }
+  if (record.kind === "spring") {
+    const resolved = resolveSpringStart(record, input.initialValue);
+    const timing2 = sampledProgress(resolved.duration, input.localTime);
+    return sampleSpring(resolved, timing2.localTime / 1e3).position;
+  }
+  const timing = sampledProgress(record.duration, input.localTime);
+  if (record.kind === "custom") {
+    const sampled = callback(record.debugName, () => record.sample(Object.freeze({
+      initialValue: input.initialValue,
+      localTime: timing.localTime,
+      progress: timing.progress
+    })));
+    return validateSampledValue(sampled, record.debugName);
+  }
+  if (record.kind === "tween") {
+    const from = record.hasFrom ? record.from : input.initialValue;
+    return interpolate(
+      from,
+      record.to,
+      easedProgress(record.easing, timing.progress, record.debugName),
+      record.interpolate,
+      record.debugName
+    );
+  }
+  keyframeSamples++;
+  keyframeSampleDepth++;
+  try {
+    return sampleKeyframe(record, timing);
+  } finally {
+    keyframeSampleDepth--;
+  }
+}
+function sampleKeyframe(record, timing) {
+  let segment = 0;
+  for (let index = 1; index < record.offsets.length; index++) {
+    if (record.offsets[index] <= timing.progress) segment = index;
+    else break;
+  }
+  if (segment === record.values.length - 1) {
+    return validateSampledValue(
+      isolateStoredAnimationValue(record.values[segment], /* @__PURE__ */ new WeakMap()),
+      record.debugName
+    );
+  }
+  const start = record.offsets[segment];
+  const end = record.offsets[segment + 1];
+  return interpolate(
+    record.values[segment],
+    record.values[segment + 1],
+    easedProgress(record.easings[segment], (timing.progress - start) / (end - start), record.debugName),
+    record.interpolate,
+    record.debugName
+  );
+}
+function activateSeekableDefinition(definition, initialValue, seen = /* @__PURE__ */ new WeakMap()) {
+  const definitionRecord = getDefinitionRecord(definition);
+  if (definitionRecord.kind === "stepper") {
+    throw new TypeError(
+      "Stateful animation definitions require the stateful program evaluator."
+    );
+  }
+  const snapshot = snapshotAnimationActivationValue(initialValue, seen);
+  const resolved = definitionRecord.kind === "spring" ? resolveSpringStart(definitionRecord, snapshot) : definitionRecord;
+  const activation = Object.freeze({
+    duration: resolved.duration,
+    initialValue: snapshot
+  });
+  seekableActivationRecords.set(
+    activation,
+    Object.freeze({
+      definition,
+      definitionRecord: resolved,
+      initialValue: snapshot
+    })
+  );
+  return activation;
+}
+function sampleActivatedSeekableDefinition(activation, localTime) {
+  const activationRecord = seekableActivationRecords.get(
+    activation
+  );
+  if (activationRecord === void 0) {
+    throw new TypeError("Expected a seekable Pibbl animation definition activation.");
+  }
+  const record = activationRecord.definitionRecord;
+  if (record.kind === "spring") {
+    const timing = sampledProgress(record.duration, localTime);
+    return sampleSpring(record, timing.localTime / 1e3).position;
+  }
+  return sampleSeekableDefinition(activationRecord.definition, {
+    initialValue: activationRecord.initialValue,
+    localTime
+  });
+}
+function getSeekableDefinitionBoundaryValue(activation, boundary) {
+  const activationRecord = seekableActivationRecords.get(
+    activation
+  );
+  if (activationRecord === void 0) {
+    throw new TypeError("Expected a seekable Pibbl animation definition activation.");
+  }
+  const record = activationRecord.definitionRecord;
+  if (record.kind === "spring") {
+    return Object.freeze({
+      kind: "known",
+      value: boundary === "start" ? record.from : record.to
+    });
+  }
+  if (record.kind === "keyframes") {
+    if (boundary === "end") {
+      return Object.freeze({ kind: "known", value: record.values.at(-1) });
+    }
+    if (record.interpolate === void 0 && record.easings[0] === easing.linear) {
+      return Object.freeze({ kind: "known", value: record.values[0] });
+    }
+    return Object.freeze({ kind: "unknown" });
+  }
+  if (record.kind === "tween" && record.interpolate === void 0 && record.easing === easing.linear) {
+    return Object.freeze({
+      kind: "known",
+      value: boundary === "start" ? record.hasFrom ? record.from : activationRecord.initialValue : record.to
+    });
+  }
+  return Object.freeze({ kind: "unknown" });
+}
+function getStaticSeekableDefinitionBoundaryValue(definition, boundary) {
+  const record = getDefinitionRecord(definition);
+  if (record.kind === "spring" && record.hasFrom) {
+    return Object.freeze({
+      kind: "known",
+      value: boundary === "start" ? record.from : record.to
+    });
+  }
+  if (record.kind === "keyframes") {
+    if (boundary === "end") {
+      return Object.freeze({ kind: "known", value: record.values.at(-1) });
+    }
+    if (record.interpolate === void 0 && record.easings[0] === easing.linear) {
+      return Object.freeze({ kind: "known", value: record.values[0] });
+    }
+  }
+  if (record.kind === "tween" && record.interpolate === void 0 && record.easing === easing.linear) {
+    if (boundary === "end") {
+      return Object.freeze({ kind: "known", value: record.to });
+    }
+    if (record.hasFrom) {
+      return Object.freeze({ kind: "known", value: record.from });
+    }
+  }
+  return Object.freeze({ kind: "unknown" });
+}
+export {
+  activateSeekableDefinition,
+  animationDefinitionPerformanceSnapshot,
+  defineAnimation,
+  getDefinitionRecord,
+  getSeekableDefinitionBoundaryValue,
+  getStaticSeekableDefinitionBoundaryValue,
+  keyframes,
+  sampleActivatedSeekableDefinition,
+  sampleSeekableDefinition,
+  snapshotAnimationActivationValue,
+  spring,
+  stepper,
+  tween
+};
+//# sourceMappingURL=definition.js.map