@hzblj/kara-sx 0.0.0-stage → 0.2.0

package/README.md

@@ -1,3 +1,8 @@
-# Temporary Holding Version
+# @hzblj/kara-sx
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+The token-typed `sx` styling engine behind kara-ui: one surface resolved into SwiftUI modifiers, Compose modifiers or a React Native style.
+
+**Install [`@hzblj/kara-ui`](https://www.npmjs.com/package/@hzblj/kara-ui) instead.** This package is one of its building
+blocks, published so the umbrella can depend on it; it is versioned together with it and has no standalone docs.
+
+MIT

package/lib/module/flatten-sx.js

@@ -0,0 +1,59 @@
+"use strict";
+
+import { BREAKPOINT_ORDER } from '@hzblj/kara-theme';
+
+/** The runtime shape of a `Responsive` object — what `isResponsive` narrows an `sx` value to. */
+
+/**
+ * No responsive-capable key takes an object value — each one is a token, a dimension, a number or a
+ * boolean — so `base` being present identifies a per-breakpoint value outright, with nothing it could
+ * be confused for. That is exactly why the visual keys stay scalar: `scale` and the platform buckets
+ * *are* objects, and admitting them would make this test ambiguous.
+ */
+const isResponsive = value => typeof value === 'object' && value !== null && 'base' in value;
+
+/** Mobile-first: the widest breakpoint declared at or below the active one, falling back to `base`. */
+const valueAt = (value, active) => {
+  let resolved = value.base;
+  if (active === 'base') {
+    return resolved;
+  }
+  for (const name of BREAKPOINT_ORDER) {
+    const declared = value[name];
+    if (declared !== undefined) {
+      resolved = declared;
+    }
+    if (name === active) {
+      break;
+    }
+  }
+  return resolved;
+};
+
+/**
+ * Collapses a responsive `sx` into the flat one the active breakpoint asks for.
+ *
+ * Deliberately upstream of the caches rather than inside them: `resolve-cache` and `sxKey` only ever
+ * see flat values, so neither their one-level key flattening nor their key space has to grow a
+ * breakpoint dimension — and two devices that land on the same flat `sx` still share its entry. A
+ * breakpoint folded into the cache key instead would have doubled the entries for every `sx` in the
+ * app, responsive or not.
+ *
+ * Hands back the very object it was given when nothing in it is responsive, which is the overwhelming
+ * case: `sx()` wraps every view, and those call sites paying nothing is what keeps it affordable.
+ */
+export const flattenSx = (sx, keys, active) => {
+  const source = sx;
+  let flattened;
+  for (const name of keys) {
+    const value = source[name];
+    if (isResponsive(value)) {
+      flattened ??= {
+        ...source
+      };
+      flattened[name] = valueAt(value, active);
+    }
+  }
+  return flattened ?? source;
+};
+//# sourceMappingURL=flatten-sx.js.map

package/lib/module/flatten-sx.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["BREAKPOINT_ORDER","isResponsive","value","valueAt","active","resolved","base","name","declared","undefined","flattenSx","sx","keys","source","flattened"],"sourceRoot":"../../src","sources":["flatten-sx.ts"],"mappings":";;AAAA,SAA+BA,gBAAgB,QAAwB,mBAAmB;;AAI1F;;AAGA;AACA;AACA;AACA;AACA;AACA;AACA,MAAMC,YAAY,GAAIC,KAAc,IAClC,OAAOA,KAAK,KAAK,QAAQ,IAAIA,KAAK,KAAK,IAAI,IAAI,MAAM,IAAIA,KAAK;;AAEhE;AACA,MAAMC,OAAO,GAAGA,CAACD,KAAsB,EAAEE,MAAwB,KAAc;EAC7E,IAAIC,QAAQ,GAAGH,KAAK,CAACI,IAAI;EAEzB,IAAIF,MAAM,KAAK,MAAM,EAAE;IACrB,OAAOC,QAAQ;EACjB;EAEA,KAAK,MAAME,IAAI,IAAIP,gBAAgB,EAAE;IACnC,MAAMQ,QAAQ,GAAGN,KAAK,CAACK,IAAI,CAAC;IAE5B,IAAIC,QAAQ,KAAKC,SAAS,EAAE;MAC1BJ,QAAQ,GAAGG,QAAQ;IACrB;IAEA,IAAID,IAAI,KAAKH,MAAM,EAAE;MACnB;IACF;EACF;EAEA,OAAOC,QAAQ;AACjB,CAAC;;AAED;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,MAAMK,SAAS,GAAGA,CACvBC,EAA2B,EAC3BC,IAAqB,EACrBR,MAAwB,KAChB;EACR,MAAMS,MAAM,GAAGF,EAA6B;EAC5C,IAAIG,SAA8C;EAElD,KAAK,MAAMP,IAAI,IAAIK,IAAI,EAAE;IACvB,MAAMV,KAAK,GAAGW,MAAM,CAACN,IAAI,CAAC;IAE1B,IAAIN,YAAY,CAACC,KAAK,CAAC,EAAE;MACvBY,SAAS,KAAK;QAAC,GAAGD;MAAM,CAAC;MACzBC,SAAS,CAACP,IAAI,CAAC,GAAGJ,OAAO,CAACD,KAAK,EAAEE,MAAM,CAAC;IAC1C;EACF;EAEA,OAAQU,SAAS,IAAID,MAAM;AAC7B,CAAC","ignoreList":[]}

package/lib/module/index.js

@@ -0,0 +1,19 @@
+"use strict";
+
+export * from "./flatten-sx.js";
+export * from "./resolve-cache.js";
+export * from "./responsive.types.js";
+export * from "./responsive-sx.js";
+export * from "./sx.types.js";
+export * from "./sx-key.js";
+export * from "./sx-keys.js";
+export * from "./sx-padding.js";
+export * from './sx-to-modifiers';
+export * from "./sx-to-style.js";
+export * from "./use-sx.js";
+export * from './use-sx-modifiers';
+export * from "./value-key.js";
+export * from "./view-sx.types.js";
+export * from "./view-sx-to-style.js";
+export * from "./with-sx.js";
+//# sourceMappingURL=index.js.map

package/lib/module/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":[],"sourceRoot":"../../src","sources":["index.ts"],"mappings":";;AAAA,cAAc,iBAAc;AAC5B,cAAc,oBAAiB;AAC/B,cAAc,uBAAoB;AAClC,cAAc,oBAAiB;AAC/B,cAAc,eAAY;AAC1B,cAAc,aAAU;AACxB,cAAc,cAAW;AACzB,cAAc,iBAAc;AAC5B,cAAc,mBAAmB;AACjC,cAAc,kBAAe;AAC7B,cAAc,aAAU;AACxB,cAAc,oBAAoB;AAClC,cAAc,gBAAa;AAC3B,cAAc,oBAAiB;AAC/B,cAAc,uBAAoB;AAClC,cAAc,cAAW","ignoreList":[]}

package/lib/module/package.json

@@ -0,0 +1 @@
+{"type":"module"}

package/lib/module/resolve-cache.js

@@ -0,0 +1,79 @@
+"use strict";
+
+import { valueKey } from "./value-key.js";
+
+/**
+ * `resolve` takes `TProps`, `split` hands back `TInput`. The same surface, except that props reach
+ * `split` straight off a component with responsive values still in them, and reach `resolve` only once
+ * `flattenSx` has collapsed those — so a caller who splits has to flatten before it can resolve.
+ * Defaults to `TProps`, for a cache whose surface has nothing responsive in it.
+ */
+
+/**
+ * Token-typed values keep the key space small, but `sx` also takes free-form numbers — an `sx`
+ * driven per frame would otherwise grow the map for the life of the app. Past the cap the whole map
+ * resets: re-resolving is cheap, and an LRU would tax every hit to soften a rare misuse.
+ */
+const MAX_CACHE_ENTRIES = 1024;
+const identities = new WeakMap();
+let nextIdentity = 0;
+
+/**
+ * The variant alone does not identify a theme's colours. On Android the palette resolver closes over a Material
+ * scheme generated at runtime, which can change while the variant stays put — a new seed, or a wallpaper change on
+ * Android 12+ — and on both platforms the app's own overrides decide what a token's hex is. Keying on the identity of
+ * the resolver *and* of the palette is what stops a resolved style outliving the colours it was built from. Both are
+ * memoised by the provider, so a steady theme costs one entry each.
+ */
+const identity = value => {
+  const existing = identities.get(value);
+  if (existing) {
+    return existing;
+  }
+  nextIdentity += 1;
+  const id = `#${nextIdentity}`;
+  identities.set(value, id);
+  return id;
+};
+export const createSxCache = (keys, resolver) => {
+  const cache = new Map();
+  const keySet = new Set(keys);
+  const cacheKey = (props, theme) => {
+    let key = `${theme.dark ? 'd' : 'l'}${identity(theme.resolver)}${identity(theme.palette)}`;
+    for (const name of keys) {
+      const value = props[name];
+      if (value !== undefined) {
+        key += `|${name}:${valueKey(value)}`;
+      }
+    }
+    return key;
+  };
+  return {
+    resolve: (props, theme) => {
+      const key = cacheKey(props, theme);
+      const cached = cache.get(key);
+      if (cached) {
+        return cached;
+      }
+      if (cache.size >= MAX_CACHE_ENTRIES) {
+        cache.clear();
+      }
+      const style = resolver(props, theme);
+      cache.set(key, style);
+      return style;
+    },
+    split: props => {
+      const owned = {};
+      const rest = {};
+      for (const name of Object.keys(props)) {
+        if (keySet.has(name)) {
+          owned[name] = props[name];
+        } else {
+          rest[name] = props[name];
+        }
+      }
+      return [owned, rest];
+    }
+  };
+};
+//# sourceMappingURL=resolve-cache.js.map

package/lib/module/resolve-cache.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["valueKey","MAX_CACHE_ENTRIES","identities","WeakMap","nextIdentity","identity","value","existing","get","id","set","createSxCache","keys","resolver","cache","Map","keySet","Set","cacheKey","props","theme","key","dark","palette","name","undefined","resolve","cached","size","clear","style","split","owned","rest","Object","has"],"sourceRoot":"../../src","sources":["resolve-cache.ts"],"mappings":";;AAEA,SAAQA,QAAQ,QAAO,gBAAa;;AAIpC;AACA;AACA;AACA;AACA;AACA;;AAMA;AACA;AACA;AACA;AACA;AACA,MAAMC,iBAAiB,GAAG,IAAI;AAE9B,MAAMC,UAAU,GAAG,IAAIC,OAAO,CAAiB,CAAC;AAEhD,IAAIC,YAAY,GAAG,CAAC;;AAEpB;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAMC,QAAQ,GAAIC,KAAa,IAAa;EAC1C,MAAMC,QAAQ,GAAGL,UAAU,CAACM,GAAG,CAACF,KAAK,CAAC;EAEtC,IAAIC,QAAQ,EAAE;IACZ,OAAOA,QAAQ;EACjB;EAEAH,YAAY,IAAI,CAAC;EAEjB,MAAMK,EAAE,GAAG,IAAIL,YAAY,EAAE;EAC7BF,UAAU,CAACQ,GAAG,CAACJ,KAAK,EAAEG,EAAE,CAAC;EAEzB,OAAOA,EAAE;AACX,CAAC;AAED,OAAO,MAAME,aAAa,GAAGA,CAC3BC,IAAwC,EACxCC,QAAuC,KACH;EACpC,MAAMC,KAAK,GAAG,IAAIC,GAAG,CAAiB,CAAC;EACvC,MAAMC,MAAM,GAAG,IAAIC,GAAG,CAASL,IAAI,CAAC;EAEpC,MAAMM,QAAQ,GAAGA,CAACC,KAAa,EAAEC,KAAY,KAAK;IAChD,IAAIC,GAAG,GAAG,GAAGD,KAAK,CAACE,IAAI,GAAG,GAAG,GAAG,GAAG,GAAGjB,QAAQ,CAACe,KAAK,CAACP,QAAQ,CAAC,GAAGR,QAAQ,CAACe,KAAK,CAACG,OAAO,CAAC,EAAE;IAE1F,KAAK,MAAMC,IAAI,IAAIZ,IAAI,EAAE;MACvB,MAAMN,KAAK,GAAGa,KAAK,CAACK,IAAI,CAAC;MAEzB,IAAIlB,KAAK,KAAKmB,SAAS,EAAE;QACvBJ,GAAG,IAAI,IAAIG,IAAI,IAAIxB,QAAQ,CAACM,KAAK,CAAC,EAAE;MACtC;IACF;IAEA,OAAOe,GAAG;EACZ,CAAC;EAED,OAAO;IACLK,OAAO,EAAEA,CAACP,KAAK,EAAEC,KAAK,KAAK;MACzB,MAAMC,GAAG,GAAGH,QAAQ,CAACC,KAAK,EAAEC,KAAK,CAAC;MAClC,MAAMO,MAAM,GAAGb,KAAK,CAACN,GAAG,CAACa,GAAG,CAAC;MAE7B,IAAIM,MAAM,EAAE;QACV,OAAOA,MAAM;MACf;MAEA,IAAIb,KAAK,CAACc,IAAI,IAAI3B,iBAAiB,EAAE;QACnCa,KAAK,CAACe,KAAK,CAAC,CAAC;MACf;MAEA,MAAMC,KAAK,GAAGjB,QAAQ,CAACM,KAAK,EAAEC,KAAK,CAAC;MACpCN,KAAK,CAACJ,GAAG,CAACW,GAAG,EAAES,KAAK,CAAC;MAErB,OAAOA,KAAK;IACd,CAAC;IACDC,KAAK,EAAEZ,KAAK,IAAI;MACd,MAAMa,KAA8B,GAAG,CAAC,CAAC;MACzC,MAAMC,IAA6B,GAAG,CAAC,CAAC;MAExC,KAAK,MAAMT,IAAI,IAAIU,MAAM,CAACtB,IAAI,CAACO,KAAK,CAAC,EAAE;QACrC,IAAIH,MAAM,CAACmB,GAAG,CAACX,IAAI,CAAC,EAAE;UACpBQ,KAAK,CAACR,IAAI,CAAC,GAAGL,KAAK,CAACK,IAAI,CAAC;QAC3B,CAAC,MAAM;UACLS,IAAI,CAACT,IAAI,CAAC,GAAGL,KAAK,CAACK,IAAI,CAAC;QAC1B;MACF;MAEA,OAAO,CAACQ,KAAK,EAAYC,IAAI,CAAC;IAChC;EACF,CAAC;AACH,CAAC","ignoreList":[]}

package/lib/module/responsive-sx.js

@@ -0,0 +1,66 @@
+"use strict";
+
+/**
+ * Layout keys only, and deliberately so: a wider screen wants a different gap, padding or column
+ * count — not a different colour. `bg`, `shadow`, the radii, `opacity`, the transforms and both
+ * platform buckets therefore stay scalar. Every key admitted here is one more that `flattenSx` walks
+ * on every render, for a kind of change a design system should not be making anyway.
+ *
+ * `Partial` because this is a subset by design; what the `satisfies` buys is the other direction — a
+ * key renamed in `SxCore` stops compiling here instead of silently going non-responsive.
+ */
+const SX_RESPONSIVE_KEY_RECORD = {
+  h: true,
+  minH: true,
+  minW: true,
+  p: true,
+  pb: true,
+  pl: true,
+  pr: true,
+  pt: true,
+  px: true,
+  py: true,
+  tall: true,
+  w: true,
+  wide: true
+};
+/** What `useSxModifiers` flattens before the SwiftUI and Compose paths see it. */
+export const SX_RESPONSIVE_KEYS = Object.keys(SX_RESPONSIVE_KEY_RECORD);
+
+/** The core keys plus what only the React Native style path has: margins, gaps, flex, sizing maxima. */
+const VIEW_RESPONSIVE_KEY_RECORD = {
+  ...SX_RESPONSIVE_KEY_RECORD,
+  align: true,
+  alignContent: true,
+  alignSelf: true,
+  basis: true,
+  columnGap: true,
+  display: true,
+  flex: true,
+  flexDirection: true,
+  gap: true,
+  grow: true,
+  justify: true,
+  m: true,
+  maxH: true,
+  maxW: true,
+  mb: true,
+  ml: true,
+  mr: true,
+  mt: true,
+  mx: true,
+  my: true,
+  rowGap: true,
+  shrink: true,
+  wrap: true
+};
+/** What `useSx` flattens before the style cache sees it. */
+export const VIEW_RESPONSIVE_KEYS = Object.keys(VIEW_RESPONSIVE_KEY_RECORD);
+
+/**
+ * The native modifier surface as a component takes it — `Sx` is the same surface once a breakpoint
+ * has been picked, which is what every resolver and cache downstream of `flattenSx` works with.
+ */
+
+/** `ViewSx` as a component takes it, standing to it as `ResponsiveSx` does to `Sx`. */
+//# sourceMappingURL=responsive-sx.js.map

package/lib/module/responsive-sx.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["SX_RESPONSIVE_KEY_RECORD","h","minH","minW","p","pb","pl","pr","pt","px","py","tall","w","wide","SX_RESPONSIVE_KEYS","Object","keys","VIEW_RESPONSIVE_KEY_RECORD","align","alignContent","alignSelf","basis","columnGap","display","flex","flexDirection","gap","grow","justify","m","maxH","maxW","mb","ml","mr","mt","mx","my","rowGap","shrink","wrap","VIEW_RESPONSIVE_KEYS"],"sourceRoot":"../../src","sources":["responsive-sx.ts"],"mappings":";;AAIA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAMA,wBAAwB,GAAG;EAC/BC,CAAC,EAAE,IAAI;EACPC,IAAI,EAAE,IAAI;EACVC,IAAI,EAAE,IAAI;EACVC,CAAC,EAAE,IAAI;EACPC,EAAE,EAAE,IAAI;EACRC,EAAE,EAAE,IAAI;EACRC,EAAE,EAAE,IAAI;EACRC,EAAE,EAAE,IAAI;EACRC,EAAE,EAAE,IAAI;EACRC,EAAE,EAAE,IAAI;EACRC,IAAI,EAAE,IAAI;EACVC,CAAC,EAAE,IAAI;EACPC,IAAI,EAAE;AACR,CAAwD;AAIxD;AACA,OAAO,MAAMC,kBAAkB,GAAGC,MAAM,CAACC,IAAI,CAAChB,wBAAwB,CAA+B;;AAErG;AACA,MAAMiB,0BAA0B,GAAG;EACjC,GAAGjB,wBAAwB;EAC3BkB,KAAK,EAAE,IAAI;EACXC,YAAY,EAAE,IAAI;EAClBC,SAAS,EAAE,IAAI;EACfC,KAAK,EAAE,IAAI;EACXC,SAAS,EAAE,IAAI;EACfC,OAAO,EAAE,IAAI;EACbC,IAAI,EAAE,IAAI;EACVC,aAAa,EAAE,IAAI;EACnBC,GAAG,EAAE,IAAI;EACTC,IAAI,EAAE,IAAI;EACVC,OAAO,EAAE,IAAI;EACbC,CAAC,EAAE,IAAI;EACPC,IAAI,EAAE,IAAI;EACVC,IAAI,EAAE,IAAI;EACVC,EAAE,EAAE,IAAI;EACRC,EAAE,EAAE,IAAI;EACRC,EAAE,EAAE,IAAI;EACRC,EAAE,EAAE,IAAI;EACRC,EAAE,EAAE,IAAI;EACRC,EAAE,EAAE,IAAI;EACRC,MAAM,EAAE,IAAI;EACZC,MAAM,EAAE,IAAI;EACZC,IAAI,EAAE;AACR,CAAwD;AAIxD;AACA,OAAO,MAAMC,oBAAoB,GAAG1B,MAAM,CAACC,IAAI,CAACC,0BAA0B,CAAmC;;AAE7G;AACA;AACA;AACA;;AAGA","ignoreList":[]}

package/lib/module/responsive.types.js

@@ -0,0 +1,4 @@
+"use strict";
+
+export {};
+//# sourceMappingURL=responsive.types.js.map

package/lib/module/responsive.types.js.map

@@ -0,0 +1 @@
+{"version":3,"names":[],"sourceRoot":"../../src","sources":["responsive.types.ts"],"mappings":"","ignoreList":[]}

package/lib/module/sx-key.js

@@ -0,0 +1,25 @@
+"use strict";
+
+import { SX_BUCKET_KEYS, SX_CORE_KEYS } from "./sx-keys.js";
+import { valueKey } from "./value-key.js";
+
+/**
+ * Keys sorted, because two buckets holding the same values can list them in a different order and
+ * still have to key alike. Object configs flatten through `valueKey`, one level — which is all the
+ * `Bucket` constraint admits. `modifiers` is skipped: it holds opaque configs, so no string stands
+ * in for it — `useSxModifiers` depends on that array itself alongside this key.
+ */
+const bucketKey = bucket => {
+  if (!bucket) {
+    return '';
+  }
+  return Object.keys(bucket).filter(name => name !== 'modifiers').sort().map(name => `${name}:${valueKey(bucket[name])}`).join(',');
+};
+
+/**
+ * A stable `useMemo` dependency for an `Sx`. Atoms take theirs from a rest spread, so the object is
+ * a fresh identity on every render even when nothing in it changed — the values flattened into one
+ * string say exactly as much as the object does.
+ */
+export const sxKey = sx => [...SX_CORE_KEYS.map(name => sx[name] === undefined ? '' : valueKey(sx[name])), ...SX_BUCKET_KEYS.map(name => bucketKey(sx[name]))].join('|');
+//# sourceMappingURL=sx-key.js.map

package/lib/module/sx-key.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["SX_BUCKET_KEYS","SX_CORE_KEYS","valueKey","bucketKey","bucket","Object","keys","filter","name","sort","map","join","sxKey","sx","undefined"],"sourceRoot":"../../src","sources":["sx-key.ts"],"mappings":";;AACA,SAAQA,cAAc,EAAEC,YAAY,QAAO,cAAW;AACtD,SAAQC,QAAQ,QAAO,gBAAa;;AAEpC;AACA;AACA;AACA;AACA;AACA;AACA,MAAMC,SAAS,GAAIC,MAA2C,IAAa;EACzE,IAAI,CAACA,MAAM,EAAE;IACX,OAAO,EAAE;EACX;EAEA,OAAOC,MAAM,CAACC,IAAI,CAACF,MAAM,CAAC,CACvBG,MAAM,CAACC,IAAI,IAAIA,IAAI,KAAK,WAAW,CAAC,CACpCC,IAAI,CAAC,CAAC,CACNC,GAAG,CAACF,IAAI,IAAI,GAAGA,IAAI,IAAIN,QAAQ,CAACE,MAAM,CAACI,IAAI,CAAC,CAAC,EAAE,CAAC,CAChDG,IAAI,CAAC,GAAG,CAAC;AACd,CAAC;;AAED;AACA;AACA;AACA;AACA;AACA,OAAO,MAAMC,KAAK,GAAIC,EAAM,IAC1B,CACE,GAAGZ,YAAY,CAACS,GAAG,CAACF,IAAI,IAAKK,EAAE,CAACL,IAAI,CAAC,KAAKM,SAAS,GAAG,EAAE,GAAGZ,QAAQ,CAACW,EAAE,CAACL,IAAI,CAAC,CAAE,CAAC,EAC/E,GAAGR,cAAc,CAACU,GAAG,CAACF,IAAI,IAAIL,SAAS,CAACU,EAAE,CAACL,IAAI,CAAC,CAAC,CAAC,CACnD,CAACG,IAAI,CAAC,GAAG,CAAC","ignoreList":[]}

package/lib/module/sx-keys.js

@@ -0,0 +1,46 @@
+"use strict";
+
+/**
+ * A `Record` rather than a bare array, because `satisfies` on an array only checks membership —
+ * here the compiler holds the list to `SxCore` in both directions, so a key added to the type but
+ * missing from this list (which `split` would then leak into `rest`) refuses to compile.
+ */
+const SX_CORE_KEY_RECORD = {
+  bg: true,
+  blur: true,
+  borderColor: true,
+  borderRadius: true,
+  borderWidth: true,
+  h: true,
+  minH: true,
+  minW: true,
+  offsetX: true,
+  offsetY: true,
+  opacity: true,
+  p: true,
+  pb: true,
+  pl: true,
+  pr: true,
+  pt: true,
+  px: true,
+  py: true,
+  rotate: true,
+  scale: true,
+  shadow: true,
+  tall: true,
+  w: true,
+  wide: true,
+  zIndex: true
+};
+
+/** The keys every target shares. The React Native style path takes these and none of the buckets. */
+export const SX_CORE_KEYS = Object.keys(SX_CORE_KEY_RECORD);
+const SX_BUCKET_KEY_RECORD = {
+  android: true,
+  ios: true
+};
+
+/** Kept apart from `SX_CORE_KEYS` so the React Native path can take the core without them. */
+export const SX_BUCKET_KEYS = Object.keys(SX_BUCKET_KEY_RECORD);
+export const SX_KEYS = [...SX_CORE_KEYS, ...SX_BUCKET_KEYS];
+//# sourceMappingURL=sx-keys.js.map

package/lib/module/sx-keys.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["SX_CORE_KEY_RECORD","bg","blur","borderColor","borderRadius","borderWidth","h","minH","minW","offsetX","offsetY","opacity","p","pb","pl","pr","pt","px","py","rotate","scale","shadow","tall","w","wide","zIndex","SX_CORE_KEYS","Object","keys","SX_BUCKET_KEY_RECORD","android","ios","SX_BUCKET_KEYS","SX_KEYS"],"sourceRoot":"../../src","sources":["sx-keys.ts"],"mappings":";;AAEA;AACA;AACA;AACA;AACA;AACA,MAAMA,kBAAkB,GAAG;EACzBC,EAAE,EAAE,IAAI;EACRC,IAAI,EAAE,IAAI;EACVC,WAAW,EAAE,IAAI;EACjBC,YAAY,EAAE,IAAI;EAClBC,WAAW,EAAE,IAAI;EACjBC,CAAC,EAAE,IAAI;EACPC,IAAI,EAAE,IAAI;EACVC,IAAI,EAAE,IAAI;EACVC,OAAO,EAAE,IAAI;EACbC,OAAO,EAAE,IAAI;EACbC,OAAO,EAAE,IAAI;EACbC,CAAC,EAAE,IAAI;EACPC,EAAE,EAAE,IAAI;EACRC,EAAE,EAAE,IAAI;EACRC,EAAE,EAAE,IAAI;EACRC,EAAE,EAAE,IAAI;EACRC,EAAE,EAAE,IAAI;EACRC,EAAE,EAAE,IAAI;EACRC,MAAM,EAAE,IAAI;EACZC,KAAK,EAAE,IAAI;EACXC,MAAM,EAAE,IAAI;EACZC,IAAI,EAAE,IAAI;EACVC,CAAC,EAAE,IAAI;EACPC,IAAI,EAAE,IAAI;EACVC,MAAM,EAAE;AACV,CAA+C;;AAE/C;AACA,OAAO,MAAMC,YAAY,GAAGC,MAAM,CAACC,IAAI,CAAC5B,kBAAkB,CAA8B;AAExF,MAAM6B,oBAAoB,GAAG;EAC3BC,OAAO,EAAE,IAAI;EACbC,GAAG,EAAE;AACP,CAAkE;;AAElE;AACA,OAAO,MAAMC,cAAc,GAAGL,MAAM,CAACC,IAAI,CAACC,oBAAoB,CAA+C;AAE7G,OAAO,MAAMI,OAA8B,GAAG,CAAC,GAAGP,YAAY,EAAE,GAAGM,cAAc,CAAC","ignoreList":[]}

package/lib/module/sx-padding.js

@@ -0,0 +1,26 @@
+"use strict";
+
+import { spacing } from '@hzblj/kara-theme';
+const size = token => token === undefined ? undefined : spacing[token];
+
+/** Padding is all this reads, so both `Sx` and the widened `StyleSx` satisfy it. */
+
+export const sxPadding = sx => {
+  const all = size(sx.p);
+  const horizontal = size(sx.px);
+  const vertical = size(sx.py);
+  const top = size(sx.pt) ?? vertical ?? all;
+  const bottom = size(sx.pb) ?? vertical ?? all;
+  const leading = size(sx.pl) ?? horizontal ?? all;
+  const trailing = size(sx.pr) ?? horizontal ?? all;
+  if (top === undefined && bottom === undefined && leading === undefined && trailing === undefined) {
+    return undefined;
+  }
+  return {
+    bottom,
+    leading,
+    top,
+    trailing
+  };
+};
+//# sourceMappingURL=sx-padding.js.map

package/lib/module/sx-padding.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["spacing","size","token","undefined","sxPadding","sx","all","p","horizontal","px","vertical","py","top","pt","bottom","pb","leading","pl","trailing","pr"],"sourceRoot":"../../src","sources":["sx-padding.ts"],"mappings":";;AAAA,SAAQA,OAAO,QAAO,mBAAmB;AAIzC,MAAMC,IAAI,GAAIC,KAA2B,IAAMA,KAAK,KAAKC,SAAS,GAAGA,SAAS,GAAGH,OAAO,CAACE,KAAK,CAAE;;AAIhG;;AAGA,OAAO,MAAME,SAAS,GAAIC,EAAkB,IAA4B;EACtE,MAAMC,GAAG,GAAGL,IAAI,CAACI,EAAE,CAACE,CAAC,CAAC;EACtB,MAAMC,UAAU,GAAGP,IAAI,CAACI,EAAE,CAACI,EAAE,CAAC;EAC9B,MAAMC,QAAQ,GAAGT,IAAI,CAACI,EAAE,CAACM,EAAE,CAAC;EAE5B,MAAMC,GAAG,GAAGX,IAAI,CAACI,EAAE,CAACQ,EAAE,CAAC,IAAIH,QAAQ,IAAIJ,GAAG;EAC1C,MAAMQ,MAAM,GAAGb,IAAI,CAACI,EAAE,CAACU,EAAE,CAAC,IAAIL,QAAQ,IAAIJ,GAAG;EAC7C,MAAMU,OAAO,GAAGf,IAAI,CAACI,EAAE,CAACY,EAAE,CAAC,IAAIT,UAAU,IAAIF,GAAG;EAChD,MAAMY,QAAQ,GAAGjB,IAAI,CAACI,EAAE,CAACc,EAAE,CAAC,IAAIX,UAAU,IAAIF,GAAG;EAEjD,IAAIM,GAAG,KAAKT,SAAS,IAAIW,MAAM,KAAKX,SAAS,IAAIa,OAAO,KAAKb,SAAS,IAAIe,QAAQ,KAAKf,SAAS,EAAE;IAChG,OAAOA,SAAS;EAClB;EAEA,OAAO;IAACW,MAAM;IAAEE,OAAO;IAAEJ,GAAG;IAAEM;EAAQ,CAAC;AACzC,CAAC","ignoreList":[]}

package/lib/module/sx-to-modifiers.android.js

@@ -0,0 +1,168 @@
+"use strict";
+
+import { align, alpha, animateContentSize, background, blur, clip, defaultMinSize, dropShadow, fillMaxHeight, fillMaxWidth, graphicsLayer, height as heightModifier, imePadding, innerShadow, matchParentSize, offset, padding, rotate, Shapes, weight, width as widthModifier, wrapContentHeight, wrapContentWidth, zIndex as zIndexModifier } from '@expo/ui/jetpack-compose/modifiers';
+import { opacity, radii, resolvePaletteColor, resolveShadow, zIndex } from '@hzblj/kara-theme';
+import { sxPadding } from "./sx-padding.js";
+
+/**
+ * The `full` radius token maps to `Circle` — Compose's `CircleShape` is a 50% rounding, so on any
+ * box it draws the same capsule the iOS resolver gets from SwiftUI's `Capsule`.
+ */
+const shapeOf = sx => {
+  if (sx.borderRadius === 'full') {
+    return Shapes.Circle;
+  }
+  return sx.borderRadius ? Shapes.RoundedCorner(radii[sx.borderRadius]) : Shapes.Rectangle;
+};
+
+/**
+ * A stroke that traces the box's own shape. `border` takes no shape, so on a rounded box it would
+ * draw a square — an inner shadow with no blur and the width as its spread is the same inset stroke
+ * that `strokeBorder` paints on iOS, and it follows the corner radius.
+ */
+const outline = (color, width, shape) => innerShadow(shape, {
+  color,
+  radius: 0,
+  spread: width
+});
+
+/**
+ * Compose has no single transform modifier, so `scale` goes through `graphicsLayer` while `rotate` and
+ * `offset` keep their own — `rotate` is the readable one for the Z axis, and `offset` moves the box
+ * before it is drawn rather than after, which is what the React Native and SwiftUI paths also do.
+ */
+const effectModifiers = sx => {
+  const modifiers = [];
+  if (sx.offsetX !== undefined || sx.offsetY !== undefined) {
+    modifiers.push(offset(sx.offsetX ?? 0, sx.offsetY ?? 0));
+  }
+  if (sx.rotate !== undefined) {
+    modifiers.push(rotate(sx.rotate));
+  }
+  if (sx.scale !== undefined) {
+    const scale = typeof sx.scale === 'number' ? {
+      x: sx.scale,
+      y: sx.scale
+    } : sx.scale;
+    modifiers.push(graphicsLayer({
+      scaleX: scale.x ?? 1,
+      scaleY: scale.y ?? 1
+    }));
+  }
+  if (sx.blur !== undefined) {
+    modifiers.push(blur(sx.blur));
+  }
+  if (sx.opacity) {
+    modifiers.push(alpha(opacity[sx.opacity]));
+  }
+  if (sx.zIndex) {
+    modifiers.push(zIndexModifier(zIndex[sx.zIndex]));
+  }
+  return modifiers;
+};
+
+/**
+ * `wrapContentWidth`/`Height` take an alignment, and `true` means "wrap, don't care where" — Compose's
+ * own default. Passing the flag straight through as the alignment would not type-check.
+ */
+const wrapAlignment = value => typeof value === 'boolean' ? undefined : value;
+
+/** The `android` bucket: Compose-only modifiers, which the SwiftUI resolver has no counterpart for. */
+const androidModifiers = android => {
+  if (!android) {
+    return [];
+  }
+  const modifiers = [];
+  if (android.align) {
+    modifiers.push(align(android.align));
+  }
+  if (android.fillMaxWidth !== undefined) {
+    modifiers.push(fillMaxWidth(android.fillMaxWidth));
+  }
+  if (android.fillMaxHeight !== undefined) {
+    modifiers.push(fillMaxHeight(android.fillMaxHeight));
+  }
+  if (android.weight !== undefined) {
+    modifiers.push(weight(android.weight));
+  }
+  if (android.wrapContentWidth) {
+    modifiers.push(wrapContentWidth(wrapAlignment(android.wrapContentWidth)));
+  }
+  if (android.wrapContentHeight) {
+    modifiers.push(wrapContentHeight(wrapAlignment(android.wrapContentHeight)));
+  }
+  if (android.matchParentSize) {
+    modifiers.push(matchParentSize());
+  }
+  if (android.imePadding) {
+    modifiers.push(imePadding());
+  }
+  if (android.animateContentSize) {
+    modifiers.push(animateContentSize());
+  }
+  if (android.modifiers) {
+    modifiers.push(...android.modifiers);
+  }
+  return modifiers;
+};
+export const sxToModifiers = (sx, theme, _alignment = 'topLeading') => {
+  const modifiers = [];
+  const shape = shapeOf(sx);
+  const shadow = sx.shadow ? resolveShadow(theme, sx.shadow) : undefined;
+  const geometry = shadow?.geometry;
+  const shadowColors = shadow?.colors;
+  if (sx.wide) {
+    modifiers.push(fillMaxWidth());
+  }
+  if (sx.tall) {
+    modifiers.push(fillMaxHeight());
+  }
+  if (sx.w !== undefined) {
+    modifiers.push(widthModifier(sx.w));
+  }
+  if (sx.h !== undefined) {
+    modifiers.push(heightModifier(sx.h));
+  }
+  if (sx.minW !== undefined || sx.minH !== undefined) {
+    modifiers.push(defaultMinSize({
+      minHeight: sx.minH,
+      minWidth: sx.minW
+    }));
+  }
+  if (geometry?.drop && shadowColors?.drop) {
+    modifiers.push(dropShadow(shape, {
+      color: resolvePaletteColor(theme, shadowColors.drop),
+      offsetY: geometry.drop.y,
+      radius: geometry.drop.radius
+    }));
+  }
+
+  // A draw modifier is only clipped by a `clip` earlier in the chain, so the clip has to come
+  // between the drop shadow — which must paint outside the box — and everything drawn within it.
+  if (sx.borderRadius) {
+    modifiers.push(clip(shape));
+  }
+  if (sx.bg) {
+    modifiers.push(background(theme.color(sx.bg)));
+  }
+  if (geometry?.inset && shadowColors?.inset) {
+    modifiers.push(innerShadow(shape, {
+      color: resolvePaletteColor(theme, shadowColors.inset),
+      radius: geometry.inset.radius
+    }));
+  }
+  if (sx.borderWidth !== undefined && sx.borderColor) {
+    modifiers.push(outline(theme.color(sx.borderColor), sx.borderWidth, shape));
+  }
+  if (geometry?.ring && shadowColors?.ring) {
+    modifiers.push(outline(resolvePaletteColor(theme, shadowColors.ring), geometry.ring.width, shape));
+  }
+  const boxPadding = sxPadding(sx);
+  if (boxPadding) {
+    modifiers.push(padding(boxPadding.leading ?? 0, boxPadding.top ?? 0, boxPadding.trailing ?? 0, boxPadding.bottom ?? 0));
+  }
+  modifiers.push(...effectModifiers(sx));
+  modifiers.push(...androidModifiers(sx.android));
+  return modifiers;
+};
+//# sourceMappingURL=sx-to-modifiers.android.js.map

package/lib/module/sx-to-modifiers.android.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["align","alpha","animateContentSize","background","blur","clip","defaultMinSize","dropShadow","fillMaxHeight","fillMaxWidth","graphicsLayer","height","heightModifier","imePadding","innerShadow","matchParentSize","offset","padding","rotate","Shapes","weight","width","widthModifier","wrapContentHeight","wrapContentWidth","zIndex","zIndexModifier","opacity","radii","resolvePaletteColor","resolveShadow","sxPadding","shapeOf","sx","borderRadius","Circle","RoundedCorner","Rectangle","outline","color","shape","radius","spread","effectModifiers","modifiers","offsetX","undefined","offsetY","push","scale","x","y","scaleX","scaleY","wrapAlignment","value","androidModifiers","android","sxToModifiers","theme","_alignment","shadow","geometry","shadowColors","colors","wide","tall","w","h","minW","minH","minHeight","minWidth","drop","bg","inset","borderWidth","borderColor","ring","boxPadding","leading","top","trailing","bottom"],"sourceRoot":"../../src","sources":["sx-to-modifiers.android.ts"],"mappings":"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","ignoreList":[]}