@wardic/solid 0.0.0-stage → 1.0.0-rc.2

package/dist/server/variant-target.js

@@ -0,0 +1,224 @@
+import * as Style from "@wardic/dom/Style";
+import * as Arr from "effect/Array";
+import * as Bool from "effect/Boolean";
+import * as Option from "effect/Option";
+import * as Predicate from "effect/Predicate";
+import * as Rec from "effect/Record";
+import * as UndefinedOr from "effect/UndefinedOr";
+/** No values yet: a server render's, and the Starting style's. */
+export const NO_VARIANT_STATE = {
+  values: {},
+  velocities: {}
+};
+/**
+ * Whether an entry names variants (#297): a name, or a list of names. Not a values map: a list is an
+ * object too, so a check for a string alone would take it for one.
+ */
+export const isLabels = entry => Bool.or(Predicate.isString(entry), Arr.isArray(entry));
+/** An entry's names, in order (#297): one for a name, a list's own, none for a values map or nothing. */
+export const labelsOf = entry => {
+  if (Predicate.isString(entry)) return [entry];
+  if (Arr.isArray(entry)) return entry;
+  return NO_LABELS;
+};
+/** No names. */
+export const NO_LABELS = [];
+/**
+ * Two entries' names the same (#297, Motion's `shallowCompare`): a name, or a list equal name by name
+ * in order, so a fresh list with the same names each render isn't a change. A values map, or nothing,
+ * matches only itself.
+ */
+export const sameLabels = (a, b) => {
+  if (a === b) return true;
+  if (Bool.or(Bool.not(Arr.isArray(a)), Bool.not(Arr.isArray(b)))) return false;
+  const x = a;
+  const y = b;
+  return Bool.and(x.length === y.length, Arr.every(x, (name, i) => name === y[i]));
+};
+/** A resolver called with what it reads, as Motion calls it; anything else as it is. */
+const calledOf = (definition, custom, state) => {
+  if (Predicate.isFunction(definition)) return definition(custom, {
+    ...state.values
+  }, {
+    ...state.velocities
+  });
+  return definition;
+};
+/** A name looked up in `variants`; anything else as it is. */
+const namedOf = (definition, variants) => {
+  if (Bool.not(Predicate.isString(definition))) return definition;
+  if (Predicate.isUndefined(variants)) return undefined;
+  return variants[definition];
+};
+/**
+ * Resolve a target (#277): a values map, or a variant name, against `variants`, Motion's
+ * `resolveVariantFromProps`. A name's entry is looked up, a resolver is called with `custom` and the
+ * element's `state`, and a resolver that returns a name is followed once more. Its values go through
+ * `Style.valuesAt`, so `Override.resolve` and `Values.split` never see an `undefined` value, nor an
+ * array: a key's Keyframes (#429) are split off, its value their last stop; its `transition` is split
+ * off too.
+ */
+export const resolveTarget = (entry, variants, custom, state) => {
+  if (Arr.isArray(entry)) return mergedOf(resolveTargets(entry, variants, custom, state));
+  return resolveOne(entry, variants, custom, state);
+};
+/**
+ * Each of an entry's targets, in order (#297): a list's names each resolved on its own, Motion's
+ * `definitionList`; a name or a values map alone. An empty list resolves nothing.
+ */
+export const resolveTargets = (entry, variants, custom, state) => {
+  if (Arr.isArray(entry)) {
+    return Arr.map(entry, name => ({
+      ...resolveOne(name, variants, custom, state),
+      name
+    }));
+  }
+  const one = entry;
+  return [{
+    ...resolveOne(one, variants, custom, state),
+    name: Bool.match(Predicate.isString(one), {
+      onTrue: () => one,
+      onFalse: () => undefined
+    })
+  }];
+};
+/**
+ * Targets merged in order (#297): their values, a later one's winning a key both set, and their own
+ * transitions field by field, a later one's winning. The merged transition is what orchestration
+ * reads for a list as a whole (`when` the last name's that sets it); each key's legs run on the own
+ * transition of the name that drives it, not on this.
+ */
+export const mergedOf = targets => Arr.reduce(targets, NO_TARGET, (merged, target) => ({
+  values: {
+    ...merged.values,
+    ...target.values
+  },
+  keyframes: keyframesOver(target, merged.keyframes),
+  transition: UndefinedOr.match(target.transition, {
+    onUndefined: () => merged.transition,
+    onDefined: own => UndefinedOr.match(merged.transition, {
+      onUndefined: () => own,
+      onDefined: before => ({
+        ...before,
+        ...own
+      })
+    })
+  }),
+  transitionEnd: UndefinedOr.match(target.transitionEnd, {
+    onUndefined: () => merged.transitionEnd,
+    onDefined: own => UndefinedOr.match(merged.transitionEnd, {
+      onUndefined: () => own,
+      onDefined: before => ({
+        ...before,
+        ...own
+      })
+    })
+  })
+}));
+/**
+ * `target`'s Keyframes over `before` (#429): a later name's own, and `before`'s for the keys it doesn't
+ * set, so a key it sets to one value is no longer Keyframes. `undefined` when neither has any.
+ */
+const keyframesOver = (target, before) => {
+  if (Predicate.isUndefined(before)) return target.keyframes;
+  const kept = Rec.filter(before, (_, key) => Bool.not(Object.hasOwn(target.values, key)));
+  const over = {
+    ...kept,
+    ...target.keyframes
+  };
+  return Bool.match(Rec.isEmptyRecord(over), {
+    onTrue: () => undefined,
+    onFalse: () => over
+  });
+};
+/** Nothing resolved. */
+export const NO_TARGET = {
+  values: {},
+  transition: undefined,
+  transitionEnd: undefined,
+  keyframes: undefined
+};
+/** One name or values map resolved ({@link resolveTarget}). */
+const resolveOne = (entry, variants, custom, state) => {
+  const definition = calledOf(namedOf(calledOf(namedOf(entry, variants), custom, state), variants), custom, state);
+  if (Bool.or(Predicate.isUndefined(definition), Bool.or(Predicate.isString(definition), Predicate.isFunction(definition)))) {
+    return NO_TARGET;
+  }
+  // Its own transition is an object; a CSS `transition` string stays a value, as it was. Its
+  // Transition end (#428) is an object too, which `toValues` leaves out of its values.
+  const target = definition;
+  const transitionEnd = transitionEndOf(target.transitionEnd);
+  // A key's Keyframes (#429) rest at their last stop: its value, beside its stops, both found in one
+  // pass over its keys (#452).
+  if (Bool.not(Predicate.isObject(target.transition))) {
+    const split = Style.splitValues(target, "last");
+    return {
+      values: split.values,
+      transition: undefined,
+      transitionEnd,
+      keyframes: Option.getOrUndefined(split.keyframes)
+    };
+  }
+  const {
+    transition,
+    ...values
+  } = target;
+  const split = Style.splitValues(values, "last");
+  return {
+    values: split.values,
+    transition: transition,
+    transitionEnd,
+    keyframes: Option.getOrUndefined(split.keyframes)
+  };
+};
+/** A target's Transition end (#428), clean for core: none for anything but a values map, or an empty one. */
+const transitionEndOf = given => {
+  if (Bool.not(Predicate.isObject(given))) return undefined;
+  const values = Style.toValues(given);
+  if (Rec.isEmptyRecord(values)) return undefined;
+  return values;
+};
+/**
+ * The transition an animation to a target runs on (#277, Motion's `resolveTransition`): the target's
+ * own in place of the element's, or laid over it with `inherit: true` (a shallow merge, its own keys
+ * winning); the element's when it has none. An own transition with no `inherit` is handed back as it
+ * is, the same object each call, so a memo of it holds (#460: a copy per call made Solid 2's variant
+ * node re-run its orchestration's readers at every gesture, `UNSTABLE_MEMO_OUTPUT`).
+ */
+export const transitionOfTarget = (own, element) => {
+  if (Predicate.isUndefined(own)) return element;
+  if (!("inherit" in own)) return own;
+  const {
+    inherit,
+    ...rest
+  } = own;
+  if (inherit === true) return {
+    ...element,
+    ...rest
+  };
+  return rest;
+};
+/**
+ * `variants` with each entry resolved to its values, a dynamic one with `custom` and no values yet
+ * (#277): what dom's Starting style reads, which takes values maps only. As they are when none is a
+ * function.
+ */
+export const startingVariantsOf = (variants, custom) => {
+  if (Predicate.isUndefined(variants)) return undefined;
+  const entries = variants;
+  if (Bool.not(Arr.some(Rec.values(entries), Predicate.isFunction))) return variants;
+  return Rec.map(entries, (_, name) => resolveTarget(name, entries, custom, NO_VARIANT_STATE).values);
+};
+/**
+ * The own transition of an element's target now (#277): its `animate` map's, else the variant it
+ * names or inherits (`name`), resolved with `custom` and no values. What its orchestration reads.
+ */
+export const ownTransitionOf = (animate, name, variants, custom) => {
+  const byName = variants;
+  if (Bool.and(Predicate.isNotUndefined(animate), Bool.not(isLabels(animate)))) {
+    return resolveTarget(animate, byName, custom, NO_VARIANT_STATE).transition;
+  }
+  if (Predicate.isUndefined(name)) return undefined;
+  return resolveTarget(name, byName, custom, NO_VARIANT_STATE).transition;
+};
+//# sourceMappingURL=variant-target.js.map

package/dist/server/variant-target.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"variant-target.js","names":["Style","Arr","Bool","Option","Predicate","Rec","UndefinedOr","NO_VARIANT_STATE","values","velocities","isLabels","entry","or","isString","isArray","labelsOf","NO_LABELS","sameLabels","a","b","not","x","y","and","length","every","name","i","calledOf","definition","custom","state","isFunction","namedOf","variants","isUndefined","undefined","resolveTarget","mergedOf","resolveTargets","resolveOne","map","one","match","onTrue","onFalse","targets","reduce","NO_TARGET","merged","target","keyframes","keyframesOver","transition","onUndefined","onDefined","own","before","transitionEnd","kept","filter","_","key","Object","hasOwn","over","isEmptyRecord","transitionEndOf","isObject","split","splitValues","getOrUndefined","given","toValues","transitionOfTarget","element","inherit","rest","startingVariantsOf","entries","some","ownTransitionOf","animate","byName","isNotUndefined"],"sources":["../../src/variant-target.ts"],"sourcesContent":[null],"mappings":"AASA,OAAO,KAAKA,KAAK,MAAM,mBAAmB;AAC1C,OAAO,KAAKC,GAAG,MAAM,cAAc;AACnC,OAAO,KAAKC,IAAI,MAAM,gBAAgB;AACtC,OAAO,KAAKC,MAAM,MAAM,eAAe;AACvC,OAAO,KAAKC,SAAS,MAAM,kBAAkB;AAC7C,OAAO,KAAKC,GAAG,MAAM,eAAe;AACpC,OAAO,KAAKC,WAAW,MAAM,oBAAoB;AAYjD;AACA,OAAO,MAAMC,gBAAgB,GAAiB;EAAEC,MAAM,EAAE,EAAE;EAAEC,UAAU,EAAE;AAAE,CAAE;AAwB5E;;;;AAIA,OAAO,MAAMC,QAAQ,GAAIC,KAAc,IAAmCT,IAAI,CAACU,EAAE,CAACR,SAAS,CAACS,QAAQ,CAACF,KAAK,CAAC,EAAEV,GAAG,CAACa,OAAO,CAACH,KAAK,CAAC,CAAC;AAEhI;AACA,OAAO,MAAMI,QAAQ,GAAIJ,KAAc,IAA2B;EAChE,IAAIP,SAAS,CAACS,QAAQ,CAACF,KAAK,CAAC,EAAE,OAAO,CAACA,KAAK,CAAC;EAC7C,IAAIV,GAAG,CAACa,OAAO,CAACH,KAAK,CAAC,EAAE,OAAOA,KAA8B;EAC7D,OAAOK,SAAS;AAClB,CAAC;AAED;AACA,OAAO,MAAMA,SAAS,GAA0B,EAAE;AAElD;;;;;AAKA,OAAO,MAAMC,UAAU,GAAGA,CAACC,CAAkC,EAAEC,CAAkC,KAAa;EAC5G,IAAID,CAAC,KAAKC,CAAC,EAAE,OAAO,IAAI;EACxB,IAAIjB,IAAI,CAACU,EAAE,CAACV,IAAI,CAACkB,GAAG,CAACnB,GAAG,CAACa,OAAO,CAACI,CAAC,CAAC,CAAC,EAAEhB,IAAI,CAACkB,GAAG,CAACnB,GAAG,CAACa,OAAO,CAACK,CAAC,CAAC,CAAC,CAAC,EAAE,OAAO,KAAK;EAC7E,MAAME,CAAC,GAAGH,CAA0B;EACpC,MAAMI,CAAC,GAAGH,CAA0B;EACpC,OAAOjB,IAAI,CAACqB,GAAG,CAACF,CAAC,CAACG,MAAM,KAAKF,CAAC,CAACE,MAAM,EAAEvB,GAAG,CAACwB,KAAK,CAACJ,CAAC,EAAE,CAACK,IAAI,EAAEC,CAAC,KAAKD,IAAI,KAAKJ,CAAC,CAACK,CAAC,CAAC,CAAC,CAAC;AAClF,CAAC;AAUD;AACA,MAAMC,QAAQ,GAAGA,CAACC,UAAsB,EAAEC,MAAe,EAAEC,KAAmB,KAAgB;EAC5F,IAAI3B,SAAS,CAAC4B,UAAU,CAACH,UAAU,CAAC,EAAE,OAAOA,UAAU,CAACC,MAAM,EAAE;IAAE,GAAGC,KAAK,CAACvB;EAAM,CAAE,EAAE;IAAE,GAAGuB,KAAK,CAACtB;EAAU,CAAE,CAAC;EAC7G,OAAOoB,UAAU;AACnB,CAAC;AAED;AACA,MAAMI,OAAO,GAAGA,CAACJ,UAAsB,EAAEK,QAAoC,KAAgB;EAC3F,IAAIhC,IAAI,CAACkB,GAAG,CAAChB,SAAS,CAACS,QAAQ,CAACgB,UAAU,CAAC,CAAC,EAAE,OAAOA,UAAU;EAC/D,IAAIzB,SAAS,CAAC+B,WAAW,CAACD,QAAQ,CAAC,EAAE,OAAOE,SAAS;EACrD,OAAOF,QAAQ,CAACL,UAAoB,CAAC;AACvC,CAAC;AAED;;;;;;;;AAQA,OAAO,MAAMQ,aAAa,GAAGA,CAAC1B,KAAY,EAAEuB,QAAoC,EAAEJ,MAAe,EAAEC,KAAmB,KAAY;EAChI,IAAI9B,GAAG,CAACa,OAAO,CAACH,KAAK,CAAC,EAAE,OAAO2B,QAAQ,CAACC,cAAc,CAAC5B,KAAK,EAAEuB,QAAQ,EAAEJ,MAAM,EAAEC,KAAK,CAAC,CAAC;EACvF,OAAOS,UAAU,CAAC7B,KAA2C,EAAEuB,QAAQ,EAAEJ,MAAM,EAAEC,KAAK,CAAC;AACzF,CAAC;AAED;;;;AAIA,OAAO,MAAMQ,cAAc,GAAGA,CAAC5B,KAAY,EAAEuB,QAAoC,EAAEJ,MAAe,EAAEC,KAAmB,KAAgC;EACrJ,IAAI9B,GAAG,CAACa,OAAO,CAACH,KAAK,CAAC,EAAE;IACtB,OAAOV,GAAG,CAACwC,GAAG,CAAC9B,KAA8B,EAAGe,IAAI,KAAmB;MAAE,GAAGc,UAAU,CAACd,IAAI,EAAEQ,QAAQ,EAAEJ,MAAM,EAAEC,KAAK,CAAC;MAAEL;IAAI,CAAE,CAAC,CAAC;EACjI;EACA,MAAMgB,GAAG,GAAG/B,KAA2C;EACvD,OAAO,CAAC;IAAE,GAAG6B,UAAU,CAACE,GAAG,EAAER,QAAQ,EAAEJ,MAAM,EAAEC,KAAK,CAAC;IAAEL,IAAI,EAAExB,IAAI,CAACyC,KAAK,CAACvC,SAAS,CAACS,QAAQ,CAAC6B,GAAG,CAAC,EAAE;MAAEE,MAAM,EAAEA,CAAA,KAAMF,GAAa;MAAEG,OAAO,EAAEA,CAAA,KAAMT;IAAS,CAAE;EAAC,CAAE,CAAC;AAChK,CAAC;AAED;;;;;;AAMA,OAAO,MAAME,QAAQ,GAAIQ,OAA8B,IACrD7C,GAAG,CAAC8C,MAAM,CAACD,OAAO,EAAEE,SAAS,EAAE,CAACC,MAAM,EAAEC,MAAM,MAAc;EAC1D1C,MAAM,EAAE;IAAE,GAAGyC,MAAM,CAACzC,MAAM;IAAE,GAAG0C,MAAM,CAAC1C;EAAM,CAAE;EAC9C2C,SAAS,EAAEC,aAAa,CAACF,MAAM,EAAED,MAAM,CAACE,SAAS,CAAC;EAClDE,UAAU,EAAE/C,WAAW,CAACqC,KAAK,CAACO,MAAM,CAACG,UAAU,EAAE;IAC/CC,WAAW,EAAEA,CAAA,KAAML,MAAM,CAACI,UAAU;IACpCE,SAAS,EAAGC,GAAG,IAAKlD,WAAW,CAACqC,KAAK,CAACM,MAAM,CAACI,UAAU,EAAE;MAAEC,WAAW,EAAEA,CAAA,KAAME,GAAG;MAAED,SAAS,EAAGE,MAAM,KAAM;QAAE,GAAGA,MAAM;QAAE,GAAGD;MAAG,CAAE;IAA4B,CAAE;GAC/J,CAAC;EACFE,aAAa,EAAEpD,WAAW,CAACqC,KAAK,CAACO,MAAM,CAACQ,aAAa,EAAE;IACrDJ,WAAW,EAAEA,CAAA,KAAML,MAAM,CAACS,aAAa;IACvCH,SAAS,EAAGC,GAAG,IAAKlD,WAAW,CAACqC,KAAK,CAACM,MAAM,CAACS,aAAa,EAAE;MAAEJ,WAAW,EAAEA,CAAA,KAAME,GAAG;MAAED,SAAS,EAAGE,MAAM,KAAM;QAAE,GAAGA,MAAM;QAAE,GAAGD;MAAG,CAAE;IAAC,CAAE;GACvI;CACF,CAAC,CAAC;AAEL;;;;AAIA,MAAMJ,aAAa,GAAGA,CAACF,MAAc,EAAEO,MAA6B,KAA2B;EAC7F,IAAIrD,SAAS,CAAC+B,WAAW,CAACsB,MAAM,CAAC,EAAE,OAAOP,MAAM,CAACC,SAAS;EAC1D,MAAMQ,IAAI,GAAGtD,GAAG,CAACuD,MAAM,CAACH,MAAM,EAAE,CAACI,CAAC,EAAEC,GAAG,KAAK5D,IAAI,CAACkB,GAAG,CAAC2C,MAAM,CAACC,MAAM,CAACd,MAAM,CAAC1C,MAAM,EAAEsD,GAAG,CAAC,CAAC,CAAC;EACxF,MAAMG,IAAI,GAAc;IAAE,GAAGN,IAAI;IAAE,GAAGT,MAAM,CAACC;EAAS,CAAE;EACxD,OAAOjD,IAAI,CAACyC,KAAK,CAACtC,GAAG,CAAC6D,aAAa,CAACD,IAAI,CAAC,EAAE;IAAErB,MAAM,EAAEA,CAAA,KAAMR,SAAS;IAAES,OAAO,EAAEA,CAAA,KAAMoB;EAAI,CAAE,CAAC;AAC9F,CAAC;AAED;AACA,OAAO,MAAMjB,SAAS,GAAW;EAAExC,MAAM,EAAE,EAAE;EAAE6C,UAAU,EAAEjB,SAAS;EAAEsB,aAAa,EAAEtB,SAAS;EAAEe,SAAS,EAAEf;AAAS,CAAE;AAEtH;AACA,MAAMI,UAAU,GAAGA,CAAC7B,KAAyC,EAAEuB,QAAoC,EAAEJ,MAAe,EAAEC,KAAmB,KAAY;EACnJ,MAAMF,UAAU,GAAGD,QAAQ,CAACK,OAAO,CAACL,QAAQ,CAACK,OAAO,CAACtB,KAAK,EAAEuB,QAAQ,CAAC,EAAEJ,MAAM,EAAEC,KAAK,CAAC,EAAEG,QAAQ,CAAC,EAAEJ,MAAM,EAAEC,KAAK,CAAC;EAChH,IAAI7B,IAAI,CAACU,EAAE,CAACR,SAAS,CAAC+B,WAAW,CAACN,UAAU,CAAC,EAAE3B,IAAI,CAACU,EAAE,CAACR,SAAS,CAACS,QAAQ,CAACgB,UAAU,CAAC,EAAEzB,SAAS,CAAC4B,UAAU,CAACH,UAAU,CAAC,CAAC,CAAC,EAAE;IACzH,OAAOmB,SAAS;EAClB;EACA;EACA;EACA,MAAME,MAAM,GAAGrB,UAAiF;EAChG,MAAM6B,aAAa,GAAGS,eAAe,CAACjB,MAAM,CAACQ,aAAa,CAAC;EAC3D;EACA;EACA,IAAIxD,IAAI,CAACkB,GAAG,CAAChB,SAAS,CAACgE,QAAQ,CAAClB,MAAM,CAACG,UAAU,CAAC,CAAC,EAAE;IACnD,MAAMgB,KAAK,GAAGrE,KAAK,CAACsE,WAAW,CAACpB,MAAM,EAAE,MAAM,CAAC;IAC/C,OAAO;MAAE1C,MAAM,EAAE6D,KAAK,CAAC7D,MAAM;MAAE6C,UAAU,EAAEjB,SAAS;MAAEsB,aAAa;MAAEP,SAAS,EAAEhD,MAAM,CAACoE,cAAc,CAACF,KAAK,CAAClB,SAAS;IAAC,CAAE;EAC1H;EACA,MAAM;IAAEE,UAAU;IAAE,GAAG7C;EAAM,CAAE,GAAG0C,MAAM;EACxC,MAAMmB,KAAK,GAAGrE,KAAK,CAACsE,WAAW,CAAC9D,MAAM,EAAE,MAAM,CAAC;EAC/C,OAAO;IAAEA,MAAM,EAAE6D,KAAK,CAAC7D,MAAM;IAAE6C,UAAU,EAAEA,UAAqC;IAAEK,aAAa;IAAEP,SAAS,EAAEhD,MAAM,CAACoE,cAAc,CAACF,KAAK,CAAClB,SAAS;EAAC,CAAE;AACtJ,CAAC;AAED;AACA,MAAMgB,eAAe,GAAIK,KAAc,IAA+B;EACpE,IAAItE,IAAI,CAACkB,GAAG,CAAChB,SAAS,CAACgE,QAAQ,CAACI,KAAK,CAAC,CAAC,EAAE,OAAOpC,SAAS;EACzD,MAAM5B,MAAM,GAAGR,KAAK,CAACyE,QAAQ,CAACD,KAAe,CAAC;EAC9C,IAAInE,GAAG,CAAC6D,aAAa,CAAC1D,MAAM,CAAC,EAAE,OAAO4B,SAAS;EAC/C,OAAO5B,MAAM;AACf,CAAC;AAED;;;;;;;AAOA,OAAO,MAAMkE,kBAAkB,GAAGA,CAAClB,GAAwC,EAAEmB,OAAqC,KAAkC;EAClJ,IAAIvE,SAAS,CAAC+B,WAAW,CAACqB,GAAG,CAAC,EAAE,OAAOmB,OAAO;EAC9C,IAAI,EAAE,SAAS,IAAInB,GAAG,CAAC,EAAE,OAAOA,GAAuB;EACvD,MAAM;IAAEoB,OAAO;IAAE,GAAGC;EAAI,CAAE,GAAGrB,GAAG;EAChC,IAAIoB,OAAO,KAAK,IAAI,EAAE,OAAO;IAAE,GAAGD,OAAO;IAAE,GAAGE;EAAI,CAAsB;EACxE,OAAOA,IAAwB;AACjC,CAAC;AAED;;;;;AAKA,OAAO,MAAMC,kBAAkB,GAAGA,CAAC5C,QAA4B,EAAEJ,MAAe,KAAwB;EACtG,IAAI1B,SAAS,CAAC+B,WAAW,CAACD,QAAQ,CAAC,EAAE,OAAOE,SAAS;EACrD,MAAM2C,OAAO,GAAG7C,QAA0B;EAC1C,IAAIhC,IAAI,CAACkB,GAAG,CAACnB,GAAG,CAAC+E,IAAI,CAAC3E,GAAG,CAACG,MAAM,CAACuE,OAAO,CAAC,EAAE3E,SAAS,CAAC4B,UAAU,CAAC,CAAC,EAAE,OAAOE,QAAQ;EAClF,OAAO7B,GAAG,CAACoC,GAAG,CAACsC,OAAO,EAAE,CAAClB,CAAC,EAAEnC,IAAI,KAAKW,aAAa,CAACX,IAAI,EAAEqD,OAAO,EAAEjD,MAAM,EAAEvB,gBAAgB,CAAC,CAACC,MAAM,CAAC;AACrG,CAAC;AAED;;;;AAIA,OAAO,MAAMyE,eAAe,GAAGA,CAC7BC,OAAiD,EACjDxD,IAAqC,EACrCQ,QAA4B,EAC5BJ,MAAe,KACwB;EACvC,MAAMqD,MAAM,GAAGjD,QAAsC;EACrD,IAAIhC,IAAI,CAACqB,GAAG,CAACnB,SAAS,CAACgF,cAAc,CAACF,OAAO,CAAC,EAAEhF,IAAI,CAACkB,GAAG,CAACV,QAAQ,CAACwE,OAAO,CAAC,CAAC,CAAC,EAAE;IAC5E,OAAO7C,aAAa,CAAC6C,OAAwB,EAAEC,MAAM,EAAErD,MAAM,EAAEvB,gBAAgB,CAAC,CAAC8C,UAAU;EAC7F;EACA,IAAIjD,SAAS,CAAC+B,WAAW,CAACT,IAAI,CAAC,EAAE,OAAOU,SAAS;EACjD,OAAOC,aAAa,CAACX,IAAI,EAAEyD,MAAM,EAAErD,MAAM,EAAEvB,gBAAgB,CAAC,CAAC8C,UAAU;AACzE,CAAC","ignoreList":[]}

package/dist/server/variant-tree.js

@@ -0,0 +1,394 @@
+/**
+ * The rules of an element's place in variant orchestration (ADR-0007, #50), Solid-free (#209): the
+ * names an element hands its children and inherits from its parent, the values it starts from, and
+ * what a server render builds. Each binding's variant node (`variant-node.ts` for Solid 1,
+ * `unstable/v2/variant-node.ts` for Solid 2) runs the orchestration over them, with its own Solid.
+ *
+ * Motion's rule (CONTEXT.md, **Variant child**):
+ * - An element that names its own variants, a name on any variant prop (`initial`, `animate`, the
+ *   `while*` gestures, `exit`; #618), hands its children its `initial` and `animate` names, and an
+ *   `initial={false}` with them (#134). Any other passes its parent's through, unless it sets
+ *   `inherit={false}`, which passes none.
+ * - A **Variant child** (`variants`, no names of its own, `inherit` not `false`) inherits its
+ *   ancestor's names and default transition, takes a stagger slot among the ancestor's variant
+ *   children, and counts for the ancestor's `when`.
+ * - An element with variants of its own (`variants`, or a name) is what its Variant children
+ *   join: it owns their registry, their stagger and their `when`. Any other element passes its
+ *   parent's context through, so a Variant child joins its nearest such ancestor; it renders no
+ *   Provider unless it sets `inherit={false}` ({@link changesContext}).
+ *
+ * @module
+ */
+import * as Stagger from "@wardic/core/Stagger";
+import * as Style from "@wardic/dom/Style";
+import * as Arr from "effect/Array";
+import * as Bool from "effect/Boolean";
+import { constTrue, constUndefined, identity } from "effect/Function";
+import * as Predicate from "effect/Predicate";
+import * as UndefinedOr from "effect/UndefinedOr";
+import { isAnimationControls } from "./animation-controls.js";
+import { isLabels, labelsOf, NO_VARIANT_STATE, resolveTarget, sameLabels, startingVariantsOf } from "./variant-target.js";
+/** The gesture layers in Motion's priority, lowest first. */
+export const GESTURE_LAYERS = ["inView", "focused", "hovered", "pressed", "dragged"];
+/** No gesture on: what an element with none active hands down. */
+export const NO_GESTURE_NAMES = {};
+/** Two {@link GestureNames} the same: the same names for each gesture, a list name by name (#297). */
+export const sameGestureNames = (a, b) => GESTURE_LAYERS.every(layer => sameLabels(a[layer], b[layer]));
+/** No gesture on. */
+export const NO_GESTURE_STATES = {
+  inView: false,
+  focused: false,
+  hovered: false,
+  pressed: false,
+  dragged: false
+};
+/** Nothing on, no labels: what an element hands down with no provider and no gesture. */
+export const NO_HAND_DOWN = {
+  on: NO_GESTURE_STATES,
+  names: NO_GESTURE_NAMES
+};
+/** Two hand-downs the same: each gesture on alike, with the same label. */
+export const sameHandDown = (a, b) => GESTURE_LAYERS.every(layer => Bool.and(a.on[layer] === b.on[layer], sameLabels(a.names[layer], b.names[layer])));
+/** What a context hands down, nothing without a context or its gestures. */
+export const handDownFrom = context => {
+  // Per Retarget, per element: guards, nothing made (most elements have no provider).
+  if (Predicate.isUndefined(context)) return NO_HAND_DOWN;
+  const gestures = context.gestures;
+  if (Predicate.isUndefined(gestures)) return NO_HAND_DOWN;
+  return gestures();
+};
+/** Each gesture on: its own, or its provider's. */
+export const gesturesOn = (own, above) => ({
+  inView: Bool.or(own.inView, above.inView),
+  focused: Bool.or(own.focused, above.focused),
+  hovered: Bool.or(own.hovered, above.hovered),
+  pressed: Bool.or(own.pressed, above.pressed),
+  dragged: Bool.or(own.dragged, above.dragged)
+});
+/** A gesture's label (#291): its own `while*`, if a name or a list (#297); with none of its own, the one it took. */
+const labelOf = (own, inherited) => {
+  if (Predicate.isNotUndefined(own)) return nameOf(own);
+  return inherited;
+};
+/** What an element hands down (#291), from its config, its own states, and what it takes. */
+export const handDownOf = (config, own, above) => ({
+  on: gesturesOn(own, above.on),
+  names: {
+    inView: labelOf(config.whileInView, above.names.inView),
+    focused: labelOf(config.whileFocus, above.names.focused),
+    hovered: labelOf(config.whileHover, above.names.hovered),
+    pressed: labelOf(config.whileTap, above.names.pressed),
+    dragged: labelOf(config.whileDrag, above.names.dragged)
+  }
+});
+/** The name each gesture's layer resolves while it's on (#291): its label then; off, none. */
+export const activeNamesOf = handDown => ({
+  inView: activeName(handDown, "inView"),
+  focused: activeName(handDown, "focused"),
+  hovered: activeName(handDown, "hovered"),
+  pressed: activeName(handDown, "pressed"),
+  dragged: activeName(handDown, "dragged")
+});
+/** A gesture's label while it's on. */
+const activeName = (handDown, layer) => {
+  if (Bool.not(handDown.on[layer])) return undefined;
+  return handDown.names[layer];
+};
+/**
+ * A key for a variant name and the active gestures' names: what a provider's orchestration snapshots
+ * at (#291), a list's names each (#297). A **Controls change** (#433) is one too, to the same name.
+ */
+export const triggerKeyOf = (variant, handDown, change) => [keyOfLabels(variant), ...GESTURE_LAYERS.map(layer => keyOfLabels(activeName(handDown, layer))), UndefinedOr.match(change, {
+  onUndefined: () => "",
+  onDefined: c => `${c.serial}`
+})].join("|");
+/** {@link ChangeAtTrigger} after a trigger `key` with `change` in effect. */
+export const changeAtTrigger = (change, key, previous) => {
+  if (Predicate.isUndefined(previous)) return {
+    change,
+    key,
+    by: change
+  };
+  if (change !== previous.change) return {
+    change,
+    key,
+    by: change
+  };
+  if (key !== previous.key) return {
+    change,
+    key,
+    by: undefined
+  };
+  return previous;
+};
+/** Each Controls change's override as a name's orchestration (#433), made once a change. */
+// Module state (#460, Q7): a cache held weakly by the object it's for, so it goes with it.
+const CHANGE_CONFIGS = new WeakMap();
+/**
+ * The orchestration every name of a list takes at a trigger a Controls change came with (#433): its
+ * override's, or `undefined` for none (each name its own).
+ */
+export const changeConfigOf = at => {
+  const by = at.by;
+  if (Predicate.isUndefined(by)) return undefined;
+  const override = by.override;
+  if (Predicate.isUndefined(override)) return undefined;
+  const known = CHANGE_CONFIGS.get(by);
+  if (Predicate.isNotUndefined(known)) return known;
+  const made = nameConfigOf(override);
+  CHANGE_CONFIGS.set(by, made);
+  return made;
+};
+/** A provider's orchestration at a trigger (#433): the override of the change it came with, else its own. */
+export const orchestrationAt = (at, own) => UndefinedOr.match(UndefinedOr.map(at.by, by => by.override), {
+  onUndefined: own,
+  onDefined: identity
+});
+/** Labels as one key: a list's names apart by a character no name has in practice. */
+const keyOfLabels = labels => Arr.join(labelsOf(labels), "\u0001");
+/** The highest-priority active gesture's name, or list (#297), if any hands one down. */
+export const topGestureName = names => UndefinedOr.match(names.dragged, {
+  onDefined: identity,
+  onUndefined: () => UndefinedOr.match(names.pressed, {
+    onDefined: identity,
+    onUndefined: () => UndefinedOr.match(names.hovered, {
+      onDefined: identity,
+      onUndefined: () => UndefinedOr.match(names.focused, {
+        onDefined: identity,
+        onUndefined: () => names.inView
+      })
+    })
+  })
+});
+/** An `initial` an element hands its children: a variant name or list (#297), `false` (#134), or `undefined` for a values map or nothing. */
+export const initialNameOf = entry => Bool.match(entry === false, {
+  onTrue: () => false,
+  onFalse: () => nameOf(entry)
+});
+/** A variant name or a list of names (#297), or `undefined` for a values map or nothing. */
+export const nameOf = entry => Bool.match(isLabels(entry), {
+  onTrue: () => entry,
+  onFalse: constUndefined
+});
+/**
+ * Whether `config` names its own variants: any of its variant props, `initial`, `animate`, the five
+ * `while*` and `exit`, is a name or a list, or its `animate` is **Animation controls** (#433), as given
+ * or as its binding marks the config it reads (Motion's `isControllingVariants`, `isVariantLabel`).
+ */
+// #618 (decision 8): Motion's `variantProps` (motion-dom 14.6 render/utils/variant-props.mjs); only
+// `initial` and `animate` counted before. Statements, not a loop over the keys: it's read per change.
+export const namesOwnVariants = config => config.controlled === true || isAnimationControls(config.animate) || isLabels(config.initial) || isLabels(config.animate) || isLabels(config.whileInView) || isLabels(config.whileFocus) || isLabels(config.whileHover) || isLabels(config.whileTap) || isLabels(config.whileDrag) || isLabels(config.exit);
+/** Whether an element has variants of its own, so Variant children join it (Motion's `isVariantNode`). */
+export const hasOwnVariants = config => Predicate.isNotUndefined(config.variants) || namesOwnVariants(config);
+/**
+ * Whether an element changes what its children read, so it renders its variant context's
+ * Provider (#50): it has variants of its own, or it sets `inherit={false}`. Any other element hands
+ * its children its parent's context as it is, so it renders none. Decided once, at setup, from the
+ * same props on a server and on the client, so the nesting never changes after mount.
+ */
+export const changesContext = config => hasOwnVariants(config) || config.inherit === false;
+/**
+ * The **Controls change** in effect for an element (#433): its own controls', else the one the context
+ * it inherits from is in, else none. Per mount, for every element (#460): guards, nothing built.
+ */
+export const controlsChangeOf = (controls, inherited) => {
+  if (Predicate.isNotUndefined(controls)) return controls;
+  if (Predicate.isUndefined(inherited)) return constUndefined;
+  const change = inherited.change;
+  if (Predicate.isUndefined(change)) return constUndefined;
+  return change;
+};
+/** Whether an element is a **Variant child** (CONTEXT.md). */
+export const isVariantChild = config => Predicate.isNotUndefined(config.variants) && !namesOwnVariants(config) && config.inherit !== false;
+/** The context an element inherits names and its default transition from: its parent's, for a Variant child. */
+export const inheritedContext = (config, parent) => {
+  // Per element at mount (#540): statements.
+  if (isVariantChild(config)) return parent;
+  return undefined;
+};
+/**
+ * The `initial` an element's Starting style resolves: its own, else the `initial` name (or `false`) of
+ * the context it inherits from (#50, #134). Read once, as every `initial` is.
+ */
+export const initialOf = (config, inherited) => UndefinedOr.match(config.initial, {
+  onDefined: initial => initial,
+  onUndefined: () => UndefinedOr.match(inherited, {
+    onUndefined: constUndefined,
+    onDefined: context => context.initial
+  })
+});
+/** The `animate` an element starts at with `initial={false}`: its own, else the name its context hands down (#134). Read once, untracked. */
+const animateOf = (config, inherited, untrack) => UndefinedOr.match(config.animate, {
+  onDefined: animate => animate,
+  onUndefined: () => UndefinedOr.match(inherited, {
+    onUndefined: constUndefined,
+    onDefined: context => untrack(context.variant)
+  })
+});
+/**
+ * Whether an element starts at its `animate`, with nothing animating at mount (#134, Motion's
+ * `isInitialAnimationBlocked`): its `initial` (own or inherited) is `false`, or it renders with an
+ * `<AnimatePresence initial={false}>`'s first render (`presenceBlocks`).
+ */
+export const startsAtAnimate = (config, inherited, presenceBlocks) => presenceBlocks || initialOf(config, inherited) === false;
+/**
+ * Whether an element's mount tells nothing (#448, Motion's `animation-state.ts`): it
+ * {@link startsAtAnimate}, or its `initial` (own, else inherited) is the same name, list or values map
+ * as its `animate` (own, else inherited). Its first Retarget, landing with nothing to animate, is told
+ * to no one. Read once, untracked.
+ */
+export const startsQuiet = (config, inherited, presenceBlocks, untrack) => {
+  if (startsAtAnimate(config, inherited, presenceBlocks)) return true;
+  const initial = initialOf(config, inherited);
+  if (Predicate.isUndefined(initial)) return false;
+  // The same map is the same entry, as the same name or list is.
+  return sameLabels(initial, animateOf(config, inherited, untrack));
+};
+/**
+ * The values an element starts from, its Starting style's input (ADR-0003): its `initial` (own, else
+ * inherited, #50), or, when it {@link startsAtAnimate}, its `animate` (own, else inherited), as
+ * Motion's `initial={false}` (#134). Read once: an inherited name is read through `untrack`.
+ */
+export const startingValuesOf = (config, inherited, presenceBlocks, untrack) => {
+  const atAnimate = startsAtAnimate(config, inherited, presenceBlocks);
+  const animate = animateOf(config, inherited, untrack);
+  const initial = initialOf(config, inherited);
+  // Per element at mount (#540): statements. Starting at `animate` resolves as `initial={false}`,
+  // and its first target is `animate`.
+  let from = initial;
+  let first = initial;
+  if (atAnimate) {
+    from = false;
+    first = animate;
+  }
+  const values = Style.resolveInitial({
+    initial: from,
+    animate,
+    // Dynamic variants resolved first (#277): dom's Starting style reads values maps only.
+    variants: startingVariantsOf(config.variants, config.custom)
+  });
+  // The first target's Transition end (#428, Motion's `makeLatestValues`): set at once, so a server
+  // renders it, and a hydration finds it.
+  if (Predicate.isUndefined(first) || first === false) return values;
+  const end = resolveTarget(first, config.variants, config.custom, NO_VARIANT_STATE).transitionEnd;
+  if (Predicate.isUndefined(end)) return values;
+  return {
+    ...values,
+    ...end
+  };
+};
+/**
+ * A name an element hands its children (Motion's `getCurrentTreeVariants`): `own` if it names its own
+ * variants, else `fromParent` unless it sets `inherit={false}`.
+ */
+export const handedDown = (config, own, fromParent) => Bool.match(namesOwnVariants(config), {
+  onTrue: own,
+  onFalse: () => Bool.match(config.inherit === false, {
+    onTrue: constUndefined,
+    onFalse: fromParent
+  })
+});
+/** An element's own transition, else the one it inherits. */
+export const ownOrInherited = (own, inherited) => UndefinedOr.match(own, {
+  onUndefined: () => UndefinedOr.map(inherited, context => context.transition()),
+  onDefined: identity
+});
+/** The stagger config an element's `transition` gives its Variant children. */
+export const staggerOf = transition => UndefinedOr.match(transition, {
+  onUndefined: () => staggerWith({}),
+  onDefined: staggerWith
+});
+/** A context's stagger config for one of its names (#297): its `staggerFor`'s, else its whole orchestration's. */
+export const staggerOfName = (context, name) => {
+  const of = context.staggerFor;
+  if (Predicate.isUndefined(of)) return context.stagger();
+  return of(name);
+};
+/** Whether a context lets a Variant child's keys of a list's name start (#297's PR 2): its `mayStartFor`, else always. */
+export const mayStartOf = (context, name) => {
+  const of = context.mayStartFor;
+  if (Predicate.isUndefined(of)) return true;
+  return of(name);
+};
+/** A child's place in a stagger, turned by its `staggerDirection`: `-1` counts from the last. */
+export const directed = (index, total, direction) => {
+  if (direction === -1) return total - 1 - index;
+  return index;
+};
+/**
+ * A child's delay in a stagger (ADR-0007): its `delayChildren` plus its place from the origin, turned
+ * by its `staggerDirection`. A function `delayChildren` (#436, Motion's `calcChildStagger`) decides it
+ * whole, from the child's index and the count. Every stagger, a Variant child's, a presence's exit's
+ * and a server's Appear timing, is placed by it.
+ */
+export const childDelayOf = (s, index, total) => {
+  if (Predicate.isFunction(s.delayChildren)) return s.delayChildren(index, total);
+  return s.delayChildren + Stagger.make(s.amount, {
+    from: s.from
+  })(directed(index, total, s.direction), total);
+};
+/** A {@link NameConfig} from the transition a name orchestrates on. */
+export const nameConfigOf = transition => ({
+  stagger: staggerOf(transition),
+  when: UndefinedOr.map(transition, t => t.when)
+});
+/** The stagger config of a transition's stagger keys, each defaulted. */
+export const staggerWith = ({
+  staggerChildren = 0,
+  delayChildren = 0,
+  from = "first",
+  staggerDirection = 1
+}) => ({
+  amount: staggerChildren,
+  delayChildren,
+  from,
+  direction: staggerDirection
+});
+/**
+ * Two stagger configs the same field by field: a memo of one holds while its orchestration changes to
+ * a transition with the same stagger (#460: a Variant child with no `press` variant, its parent
+ * pressed, made a new, equal config at each press and release, `UNSTABLE_MEMO_OUTPUT`).
+ */
+export const sameStagger = (a, b) => a.amount === b.amount && a.delayChildren === b.delayChildren && a.from === b.from && a.direction === b.direction;
+/** What an element provides when it has no variants of its own: its parent's context, unless `inherit={false}`. */
+export const passedThrough = (config, parent) => Bool.match(config.inherit === false, {
+  onTrue: constUndefined,
+  onFalse: () => parent
+});
+/** A registration that does nothing: a server render has no orchestration to join. */
+export const INERT_REGISTRATION = Object.freeze({
+  index: () => 0,
+  total: () => 1,
+  setSettled: () => {},
+  dispose: () => {}
+});
+/**
+ * {@link createVariantNode} during a server render: the same names, read once, and orchestration
+ * that does nothing. No runtime, no signals.
+ */
+export const serverVariantNode = (config, parent) => {
+  const inherited = inheritedContext(config, parent);
+  const own = () => {
+    const variant = handedDown(config, () => nameOf(config.animate), () => UndefinedOr.map(parent, p => p.variant()));
+    const transition = ownOrInherited(config.transition, inherited);
+    const stagger = staggerOf(config.transition);
+    return {
+      variant: () => variant,
+      initial: handedDown(config, () => initialNameOf(config.initial), () => UndefinedOr.map(parent, p => p.initial)),
+      transition: () => transition,
+      register: () => INERT_REGISTRATION,
+      stagger: () => stagger,
+      when: () => UndefinedOr.map(config.transition, t => t.when),
+      childrenMayStart: constTrue,
+      allChildrenSettled: constTrue
+    };
+  };
+  return {
+    provided: Bool.match(hasOwnVariants(config), {
+      onTrue: own,
+      onFalse: () => passedThrough(config, parent)
+    }),
+    inherited
+  };
+};
+//# sourceMappingURL=variant-tree.js.map