@unrulysystems/native-motion 0.1.0-alpha.0

package/src/native/motion/staticLengthGate.ts

@@ -0,0 +1,86 @@
+// U6 (REQ-VALUETYPE-013(f)) — the ONE static-style boundary for positional length strings RN
+// cannot express. A static `calc(…)` (simple binary) or vw/vh string on a layout length key
+// (left/right/top/bottom/width/height) resolves to px through the EXISTING core
+// resolveLengthToPx against the host's length layout context (the viewport context is seeded
+// at mount, so a viewport-dependent static seed lays out correctly on first mount). Strings RN
+// expresses natively (%/auto) and numbers pass through UNTOUCHED. Resolution refusals are
+// COLLECTED, never thrown here: the component routes them through the severity law and STRIPS
+// the key from the host style (the staticTransformGate strip precedent) — never a silent Yoga
+// drop. A malformed unclosed `calc(` is intercepted by isCalc's prefix match and refused, never
+// passed through.
+
+import {
+  isCalc,
+  isLengthTarget,
+  parseLengthTarget,
+  resolveLengthToPx,
+  type LengthLayoutContext,
+} from '@unrulysystems/native-motion-core'
+
+// The layout length keys the static boundary resolves (REQ-VALUETYPE-013(f)). Static x/y
+// transform strings stay with staticTransformGate; margins/padding/gap stay passthrough (no
+// catalog demand). The literal const is the single authority the public MotionViewStyle union
+// and this gate both derive from (the mappedKeys.ts pattern).
+export const STATIC_LENGTH_STYLE_KEYS = [
+  'left',
+  'right',
+  'top',
+  'bottom',
+  'width',
+  'height',
+] as const
+
+/** The layout length keys whose static grammar strings the public MotionViewStyle admits (U6). */
+export type StaticLengthStyleKey = (typeof STATIC_LENGTH_STYLE_KEYS)[number]
+
+/** The REQ-VALUETYPE-013 static grammar strings RN cannot express (resolved to px at the boundary). */
+export type StaticLengthGrammarString = `calc(${string})` | `${number}vw` | `${number}vh`
+
+/** One severity-routed refusal: the key to strip and the typed core error that refused it. */
+export type StaticLengthStyleRefusal = {
+  readonly key: StaticLengthStyleKey
+  readonly error: Error
+}
+
+/** U6 gate result: resolved px replacements vs severity-refused keys to strip. */
+export type StaticLengthStyleGate = {
+  readonly resolved: Readonly<Record<string, number>>
+  readonly refusals: readonly StaticLengthStyleRefusal[]
+}
+
+// A bare vw/vh unit number (the REQ-VALUETYPE-002 grammar). isLengthTarget is the total
+// predicate, so the throwing parse cannot fault here — never bare try/catch over
+// parseLengthTarget for classification.
+function isViewportUnitLength(raw: string): boolean {
+  if (!isLengthTarget(raw)) return false
+  const parsed = parseLengthTarget(raw)
+  return parsed.kind === 'vw' || parsed.kind === 'vh'
+}
+
+/**
+ * Classify every authored layout length key on a flattened static style bag. Numbers and
+ * strings RN expresses natively (%/auto) pass through untouched; calc(…) (isCalc's prefix
+ * catches malformed unclosed forms too) and vw/vh resolve through the existing
+ * resolveLengthToPx. A resolution refusal (out-of-grammar calc, missing context, non-finite)
+ * is collected for the component's severity lane, which strips the key.
+ */
+export function gateStaticLengthStyle(
+  style: Readonly<Record<string, unknown>>,
+  ctx: LengthLayoutContext,
+): StaticLengthStyleGate {
+  const resolved: Record<string, number> = {}
+  const refusals: StaticLengthStyleRefusal[] = []
+  for (let i = 0; i < STATIC_LENGTH_STYLE_KEYS.length; i++) {
+    const key = STATIC_LENGTH_STYLE_KEYS[i]!
+    if (!Object.prototype.hasOwnProperty.call(style, key)) continue
+    const value = style[key]
+    if (typeof value !== 'string') continue
+    if (!isCalc(value) && !isViewportUnitLength(value)) continue
+    try {
+      resolved[key] = resolveLengthToPx(value, key, ctx)
+    } catch (error) {
+      refusals.push({ key, error: error instanceof Error ? error : new Error(String(error)) })
+    }
+  }
+  return { resolved, refusals }
+}

package/src/native/motion/styleBaseGate.ts

@@ -0,0 +1,72 @@
+// The animated-key style-base gate (r14 major 10, REQ-API-010/011; R13 value-breadth amend):
+// R4 mapped the layout-prop class, whose RN style types admit non-numeric bases ('50%', 'auto').
+// Measure-resolved length forms are accepted through the ONE key-aware executable matrix
+// (review 91d41675d511): positional keys only, auto for width/height only — the controller
+// resolves them to px via layout context before seeding. Unsupported string bases still refuse
+// under the severity law. Non-animated string bases never enter the gate.
+
+import {
+  describeValue,
+  isDiscreteKeyword,
+  isLengthTarget,
+  parseValue,
+} from '@unrulysystems/native-motion-core'
+import { executableLengthValueRefusal } from '@unrulysystems/native-motion-core/internal-driver'
+import { nativeMountTargetValueKind } from './shippedSurface'
+import type { StyleValueGate } from './styleValueBinding'
+
+function isSeedableLengthBase(key: string, base: string): boolean {
+  // Total recognition — named refusals are false; unexpected faults do not hide here. The matrix
+  // owns the key law (positional axes, auto for width/height only).
+  return isLengthTarget(base) && executableLengthValueRefusal(key, base) === null
+}
+
+const THROW_GATE: StyleValueGate = {
+  severity: 'development',
+  report: () => {},
+  componentId: '<Motion.View>',
+}
+
+/**
+ * Refuse every animated key whose static base the numeric lanes cannot seed. `rgbaKeys` names
+ * the keys the color-progress lane owns (string bases are ITS contract). Returns the refused
+ * keys so the production path can drop them from the mount set.
+ */
+export function gateAnimatedStyleBases(
+  animatedKeys: readonly string[],
+  statics: Readonly<Record<string, unknown>>,
+  gate: StyleValueGate = THROW_GATE,
+  rgbaKeys: readonly string[] = [],
+): string[] {
+  const refused: string[] = []
+  for (const key of animatedKeys) {
+    const base = statics[key]
+    if (base === undefined || typeof base === 'number') continue
+    if (rgbaKeys.includes(key)) continue
+    // T23 B2b: a discrete-typed key's keyword-string base is the discrete lane's own contract
+    // (the rgba mirror) — derived from the ONE classification source, validated as the family.
+    if (
+      nativeMountTargetValueKind(key) === 'discrete' &&
+      typeof base === 'string' &&
+      isDiscreteKeyword(base) &&
+      parseValue(base).kind === 'discrete'
+    ) {
+      continue
+    }
+    // REQ-VALUETYPE-013: only executable measure-resolved strings seed — positional keys, auto
+    // for width/height only. opacity/"auto" and x:"auto" must not slip through as length bases.
+    if (typeof base === 'string' && isSeedableLengthBase(key, base)) {
+      continue
+    }
+    const error = new Error(
+      `${gate.componentId}: '${key}' is animated but its authored style base is ` +
+        `${describeValue(base)} — not a seedable numeric base for this key ` +
+        '(REQ-API-010/011, REQ-VALUETYPE-013; measure-resolved length strings only on ' +
+        'width/height/inset/x/y).',
+    )
+    if (gate.severity === 'development') throw error
+    gate.report(error)
+    refused.push(key)
+  }
+  return refused
+}