@yahoo/uds-create-config 4.6.0 → 4.8.0

package/dist/spec/visibility.js

@@ -0,0 +1,109 @@
+import { refLeaf } from "../framework/utils/refs.js";
+import { ruleApplies } from "../framework/layer-styles.js";
+import { andListOf, spelled, statePointerProp } from "../framework/render-spec.js";
+//#region src/spec/visibility.ts
+function isOr(clause) {
+	return typeof clause === "object" && clause !== null && Array.isArray(clause.$or);
+}
+function isTest(clause) {
+	return typeof clause === "object" && clause !== null && typeof clause.$state === "string";
+}
+/** The tests of the clause that excludes `cellProps`, one per pinned axis, in axis order. */
+function exclusionTests(cellProps) {
+	return Object.keys(cellProps).sort((a, b) => a.localeCompare(b)).map((axis) => ({
+		$state: `/${axis}`,
+		neq: refLeaf(cellProps[axis])
+	}));
+}
+/**
+* The clause that hides a layer at one coordinate, or `null` for a cell that pins nothing: a
+* zero-axis component has one cell, and hiding the layer there is deleting it.
+*/
+function variantExclusion(cellProps) {
+	const tests = exclusionTests(cellProps);
+	if (tests.length === 0) return null;
+	return tests.length === 1 ? tests[0] : { $or: tests };
+}
+/** Whether a stored test is exactly `axis differs from value`: a `neq` on that prop and nothing more. */
+function sameTest(stored, wanted) {
+	if (!isExclusionTest(stored)) return false;
+	if (statePointerProp(stored.$state) !== statePointerProp(wanted.$state)) return false;
+	return refLeaf(stored.neq) === refLeaf(wanted.neq);
+}
+function sameClause(stored, wanted) {
+	if (isOr(wanted)) {
+		if (!isOr(stored) || stored.$or.length !== wanted.$or.length) return false;
+		return wanted.$or.every((test) => stored.$or.some((candidate) => sameTest(candidate, test)));
+	}
+	return sameTest(stored, wanted);
+}
+/** Whether a clause is an exclusion of some coordinate: a bare `neq` test, or an `$or` of only those. */
+function isExclusion(clause) {
+	if (isOr(clause)) return clause.$or.every((test) => isExclusionTest(test));
+	return isExclusionTest(clause);
+}
+/** A `neq` test and nothing beside it: `not`, `eq` or a second operator makes it somebody else's. */
+function isExclusionTest(test) {
+	return isTest(test) && "neq" in test && Object.keys(test).every((key) => key === "$state" || key === "neq");
+}
+/**
+* A condition split into the clauses the eye writes, one per variant a layer is hidden in, and the
+* rest, which is what a boolean binding reads and edits. A surface that rewrites the rest puts the
+* exclusions back with `spelledWith`, so a hide in one variant survives a change of binding.
+*/
+function splitVariantExclusions(visible) {
+	const exclusions = [];
+	const rest = [];
+	for (const member of andListOf(visible)) if (isExclusion(member)) exclusions.push(member);
+	else rest.push(member);
+	return {
+		exclusions,
+		rest
+	};
+}
+/** The stored spelling of `clauses` followed by `exclusions`: `null` for none, a bare clause for one,
+*  the and-list for several. */
+function spelledWith({ clauses, exclusions }) {
+	return spelled([...clauses, ...exclusions]);
+}
+/** Whether the node's condition carries the eye's exclusion for this cell. */
+function excludesVariant({ visible, cellProps }) {
+	const clause = variantExclusion(cellProps);
+	if (!clause) return false;
+	return andListOf(visible).some((member) => sameClause(member, clause));
+}
+/**
+* The condition with this cell excluded: the stored one plus the clause, or unchanged when the
+* clause is already there. `undefined` when the cell pins nothing, since there is no coordinate to
+* exclude.
+*/
+function withVariantHidden({ visible, cellProps }) {
+	const clause = variantExclusion(cellProps);
+	if (!clause) return void 0;
+	if (visible === false) return false;
+	const list = andListOf(visible);
+	if (list.some((member) => sameClause(member, clause))) return spelled(list);
+	return spelled([...list, clause]);
+}
+/**
+* The condition with this cell's exclusion taken out, `null` when nothing is left (which clears the
+* field), or `undefined` when the condition never excluded it.
+*/
+function withVariantShown({ visible, cellProps }) {
+	const clause = variantExclusion(cellProps);
+	if (!clause) return void 0;
+	const list = andListOf(visible);
+	const kept = list.filter((member) => !sameClause(member, clause));
+	if (kept.length === list.length) return void 0;
+	return spelled(kept);
+}
+/**
+* The style rules that hide `layer` with `display: none` under `state`, in stored order. The
+* projection keeps no source for a hidden layer, so a surface asking which rule hid it reads them
+* here.
+*/
+function layerHidingRules({ component, layer, state }) {
+	return Object.values(component.styles ?? {}).filter((rule) => rule.layers?.[layer]?.display === "none" && ruleApplies(rule.when, state));
+}
+//#endregion
+export { excludesVariant, layerHidingRules, spelledWith, splitVariantExclusions, variantExclusion, withVariantHidden, withVariantShown };