zyzz 0.0.21 → 0.0.22

package/native/NativeZyzz.cpp

@@ -0,0 +1,215 @@
+/** Applies scoped style changes and preserves them through Fabric commits. */
+#include "NativeZyzz.h"
+#include <functional>
+#include <unordered_set>
+#include <jsi/JSIDynamic.h>
+#include <react/renderer/bridging/bridging.h>
+#include <react/renderer/core/PropsParserContext.h>
+#include <react/renderer/mounting/ShadowTree.h>
+#include <react/renderer/mounting/ShadowTreeRegistry.h>
+
+namespace facebook::react {
+
+thread_local const NativeZyzz *NativeZyzz::writing_ = nullptr;
+
+NativeZyzz::NativeZyzz(std::shared_ptr<CallInvoker> invoker)
+    : NativeZyzzCxxSpec(std::move(invoker)) {}
+
+NativeZyzz::~NativeZyzz() {
+  if (manager_) manager_->unregisterCommitHook(*this);
+}
+
+double NativeZyzz::attach(jsi::Runtime &runtime, jsi::Object node, jsi::Object props) {
+  auto shadowNode = Bridging<std::shared_ptr<const ShadowNode>>::fromJs(
+      runtime, jsi::Value(runtime, node));
+  auto values = jsi::dynamicFromValue(runtime, jsi::Value(runtime, props));
+  if (!values.isObject()) throw jsi::JSError(runtime, "Native styles must be an object.");
+
+  if (!binding_) {
+    binding_ = UIManagerBinding::getBinding(runtime);
+    if (!binding_) throw jsi::JSError(runtime, "Zyzz requires Fabric.");
+    manager_ = &binding_->getUIManager();
+    manager_->registerCommitHook(*this);
+  }
+
+  double id;
+  {
+    std::lock_guard<std::mutex> lock(mutex_);
+    id = ++nextId_;
+    entries_.emplace(id, Entry{shadowNode->getFamilyShared(), values, values,
+                               folly::dynamic::object(), shadowNode->getProps(), nullptr});
+  }
+  // A React commit can restore its earlier rendered props before the ref relinks.
+  write({{shadowNode->getTag(), std::move(values)}});
+  return id;
+}
+
+void NativeZyzz::detach(jsi::Runtime &, double id) {
+  std::shared_ptr<ShadowNodeFamily> family;
+  Props::Shared authored;
+  {
+    std::lock_guard<std::mutex> lock(mutex_);
+    const auto entry = entries_.find(id);
+    if (entry == entries_.end()) return;
+    if (!entry->second.overlay.empty()) {
+      family = entry->second.family.lock();
+      authored = entry->second.authored;
+    }
+    entries_.erase(entry);
+  }
+  if (!family || !authored) return;
+  // The React commit has already passed through the overlay hook when an old
+  // ref is detached. Restore that commit's authored props, not the old style.
+  manager_->getShadowTreeRegistry().visit(family->getSurfaceId(), [&](const ShadowTree &tree) {
+    tree.commit([&](const RootShadowNode &root) {
+      return std::static_pointer_cast<RootShadowNode>(root.cloneTree(*family,
+          [&](const ShadowNode &node) { return node.clone({.props = authored}); }));
+    }, {.mountSynchronously = true});
+  });
+}
+
+jsi::Object NativeZyzz::inspect(jsi::Runtime &runtime) {
+  std::lock_guard<std::mutex> lock(mutex_);
+  jsi::Object result(runtime);
+  result.setProperty(runtime, "batches", batches_);
+  result.setProperty(runtime, "bindings", static_cast<double>(entries_.size()));
+  result.setProperty(runtime, "writes", writes_);
+  return result;
+}
+
+void NativeZyzz::update(jsi::Runtime &runtime, std::vector<jsi::Object> updates) {
+  std::vector<std::pair<double, folly::dynamic>> selections;
+  for (const auto &update : updates) {
+    auto id = update.getProperty(runtime, "id").asNumber();
+    auto props = jsi::dynamicFromValue(runtime, update.getProperty(runtime, "props"));
+    if (!props.isObject()) throw jsi::JSError(runtime, "Native styles must be an object.");
+    selections.emplace_back(id, std::move(props));
+  }
+
+  std::unordered_map<Tag, folly::dynamic> patches;
+  {
+    std::lock_guard<std::mutex> lock(mutex_);
+    for (auto &[id, selected] : selections) {
+      auto entry = entries_.find(id);
+      if (entry == entries_.end()) continue;
+      auto family = entry->second.family.lock();
+      if (!family) {
+        entries_.erase(entry);
+        continue;
+      }
+      if (selected == entry->second.selected) continue;
+
+      folly::dynamic overlay = folly::dynamic::object();
+      for (const auto &item : selected.items()) {
+        auto rendered = entry->second.rendered.find(item.first);
+        if (rendered == entry->second.rendered.items().end() ||
+            rendered->second != item.second)
+          overlay[item.first] = item.second;
+      }
+      for (const auto &item : entry->second.rendered.items())
+        if (selected.find(item.first) == selected.items().end()) overlay[item.first] = nullptr;
+
+      auto patch = selected;
+      for (const auto &item : entry->second.selected.items())
+        if (selected.find(item.first) == selected.items().end()) patch[item.first] = nullptr;
+
+      entry->second.overlay = std::move(overlay);
+      entry->second.selected = std::move(selected);
+      patches.insert_or_assign(family->getTag(), std::move(patch));
+    }
+    if (patches.empty()) return;
+    ++batches_;
+    writes_ += patches.size();
+  }
+  write(std::move(patches));
+}
+
+void NativeZyzz::write(std::unordered_map<Tag, folly::dynamic> patches) {
+  const auto previous = writing_;
+  writing_ = this;
+  try {
+    manager_->updateShadowTree(std::move(patches));
+  } catch (...) {
+    writing_ = previous;
+    throw;
+  }
+  writing_ = previous;
+}
+
+std::shared_ptr<RootShadowNode> NativeZyzz::shadowTreeWillCommit(
+    const ShadowTree &tree,
+    const std::shared_ptr<const RootShadowNode> &,
+    const std::shared_ptr<RootShadowNode> &next) noexcept {
+  struct Overlay {
+    std::shared_ptr<ShadowNodeFamily> family;
+    folly::dynamic props;
+    double id;
+  };
+  std::unordered_map<const ShadowNodeFamily *, Overlay> overlays;
+  {
+    std::lock_guard<std::mutex> lock(mutex_);
+    for (auto entry = entries_.begin(); entry != entries_.end();) {
+      auto family = entry->second.family.lock();
+      if (!family) {
+        entry = entries_.erase(entry);
+        continue;
+      }
+      if (family->getSurfaceId() == tree.getSurfaceId() &&
+          !entry->second.overlay.empty())
+        overlays.emplace(family.get(), Overlay{family, entry->second.overlay, entry->first});
+      ++entry;
+    }
+  }
+  if (overlays.empty()) return next;
+
+  std::unordered_set<const ShadowNodeFamily *> paths;
+  for (const auto &[family, overlay] : overlays) {
+    paths.insert(family);
+    for (const auto &[ancestor, index] : overlay.family->getAncestors(*next))
+      paths.insert(&ancestor.get().getFamily());
+  }
+
+  PropsParserContext context{tree.getSurfaceId(),
+                             *manager_->getContextContainer()};
+  std::function<std::shared_ptr<const ShadowNode>(
+      const std::shared_ptr<const ShadowNode> &)> visit =
+      [&](const std::shared_ptr<const ShadowNode> &node) {
+    if (paths.find(&node->getFamily()) == paths.end()) return node;
+
+    std::shared_ptr<std::vector<std::shared_ptr<const ShadowNode>>> children;
+    const auto &current = node->getChildren();
+    for (size_t index = 0; index < current.size(); ++index) {
+      auto child = visit(current[index]);
+      if (child == current[index]) continue;
+      if (!children)
+        children = std::make_shared<
+            std::vector<std::shared_ptr<const ShadowNode>>>(current);
+      (*children)[index] = std::move(child);
+    }
+
+    const auto overlay = overlays.find(&node->getFamily());
+    if (!children && overlay == overlays.end()) return node;
+    auto props = overlay == overlays.end()
+        ? node->getProps()
+        : node->getComponentDescriptor().cloneProps(
+              context, node->getProps(), RawProps(overlay->second.props));
+    if (overlay != overlays.end()) {
+      std::lock_guard<std::mutex> lock(mutex_);
+      const auto entry = entries_.find(overlay->second.id);
+      if (entry != entries_.end()) {
+        // Skip our own native patches and nodes reused from an earlier overlay.
+        if (writing_ != this && node->getProps() != entry->second.applied)
+          entry->second.authored = node->getProps();
+        entry->second.applied = props;
+      }
+    }
+    return std::shared_ptr<const ShadowNode>(node->clone({
+        .props = props,
+        .children = children ? children : ShadowNodeFragment::childrenPlaceholder(),
+    }));
+  };
+  return std::const_pointer_cast<RootShadowNode>(
+      std::static_pointer_cast<const RootShadowNode>(visit(next)));
+}
+
+}

package/native/NativeZyzz.h

@@ -0,0 +1,52 @@
+/** Owns Fabric style overlays for one React Native runtime. */
+#pragma once
+
+#include "ZyzzSpecJSI.h"
+#include <folly/dynamic.h>
+#include <react/renderer/uimanager/UIManagerBinding.h>
+#include <react/renderer/uimanager/UIManagerCommitHook.h>
+#include <mutex>
+#include <unordered_map>
+
+namespace facebook::react {
+
+class NativeZyzz : public NativeZyzzCxxSpec<NativeZyzz>, public UIManagerCommitHook {
+ public:
+  explicit NativeZyzz(std::shared_ptr<CallInvoker> invoker);
+  ~NativeZyzz() override;
+
+  double attach(jsi::Runtime &runtime, jsi::Object node, jsi::Object props);
+  void detach(jsi::Runtime &runtime, double id);
+  jsi::Object inspect(jsi::Runtime &runtime);
+  void update(jsi::Runtime &runtime, std::vector<jsi::Object> updates);
+
+  void commitHookWasRegistered(const UIManager &) noexcept override {}
+  void commitHookWasUnregistered(const UIManager &) noexcept override {}
+  std::shared_ptr<RootShadowNode> shadowTreeWillCommit(
+      const ShadowTree &tree,
+      const std::shared_ptr<const RootShadowNode> &previous,
+      const std::shared_ptr<RootShadowNode> &next) noexcept override;
+
+ private:
+  struct Entry {
+    std::weak_ptr<ShadowNodeFamily> family;
+    folly::dynamic rendered;
+    folly::dynamic selected;
+    folly::dynamic overlay;
+    Props::Shared authored;
+    Props::Shared applied;
+  };
+
+  void write(std::unordered_map<Tag, folly::dynamic> patches);
+  static thread_local const NativeZyzz *writing_;
+
+  std::shared_ptr<UIManagerBinding> binding_;
+  UIManager *manager_ = nullptr;
+  std::unordered_map<double, Entry> entries_;
+  std::mutex mutex_;
+  double nextId_ = 0;
+  double batches_ = 0;
+  double writes_ = 0;
+};
+
+}

package/native/ZyzzSpecJSI.h

@@ -0,0 +1,65 @@
+/**
+ * This code was generated by [react-native-codegen](https://www.npmjs.com/package/react-native-codegen).
+ *
+ * Do not edit this file as changes may cause incorrect behavior and will be lost
+ * once the code is regenerated.
+ *
+ * @generated by codegen project: GenerateModuleH.js
+ */
+
+#pragma once
+
+#include <ReactCommon/TurboModule.h>
+#include <react/bridging/Bridging.h>
+
+namespace facebook::react {
+
+
+template <typename T>
+class JSI_EXPORT NativeZyzzCxxSpec : public TurboModule {
+public:
+  static constexpr std::string_view kModuleName = "NativeZyzz";
+
+protected:
+  NativeZyzzCxxSpec(std::shared_ptr<CallInvoker> jsInvoker) : TurboModule(std::string{NativeZyzzCxxSpec::kModuleName}, jsInvoker) {
+    methodMap_["attach"] = MethodMetadata {.argCount = 2, .invoker = __attach};
+    methodMap_["detach"] = MethodMetadata {.argCount = 1, .invoker = __detach};
+    methodMap_["inspect"] = MethodMetadata {.argCount = 0, .invoker = __inspect};
+    methodMap_["update"] = MethodMetadata {.argCount = 1, .invoker = __update};
+  }
+
+private:
+  static jsi::Value __attach(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
+    static_assert(
+      bridging::getParameterCount(&T::attach) == 3,
+      "Expected attach(...) to have 3 parameters");
+    return bridging::callFromJs<double>(rt, &T::attach,  static_cast<NativeZyzzCxxSpec*>(&turboModule)->jsInvoker_, static_cast<T*>(&turboModule),
+      count <= 0 ? throw jsi::JSError(rt, "Expected argument in position 0 to be passed") : args[0].asObject(rt),
+      count <= 1 ? throw jsi::JSError(rt, "Expected argument in position 1 to be passed") : args[1].asObject(rt));
+  }
+
+  static jsi::Value __detach(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
+    static_assert(
+      bridging::getParameterCount(&T::detach) == 2,
+      "Expected detach(...) to have 2 parameters");
+    bridging::callFromJs<void>(rt, &T::detach,  static_cast<NativeZyzzCxxSpec*>(&turboModule)->jsInvoker_, static_cast<T*>(&turboModule),
+      count <= 0 ? throw jsi::JSError(rt, "Expected argument in position 0 to be passed") : args[0].asNumber());return jsi::Value::undefined();
+  }
+
+  static jsi::Value __inspect(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* /*args*/, size_t /*count*/) {
+    static_assert(
+      bridging::getParameterCount(&T::inspect) == 1,
+      "Expected inspect(...) to have 1 parameters");
+    return bridging::callFromJs<jsi::Object>(rt, &T::inspect,  static_cast<NativeZyzzCxxSpec*>(&turboModule)->jsInvoker_, static_cast<T*>(&turboModule));
+  }
+
+  static jsi::Value __update(jsi::Runtime &rt, TurboModule &turboModule, const jsi::Value* args, size_t count) {
+    static_assert(
+      bridging::getParameterCount(&T::update) == 2,
+      "Expected update(...) to have 2 parameters");
+    bridging::callFromJs<void>(rt, &T::update,  static_cast<NativeZyzzCxxSpec*>(&turboModule)->jsInvoker_, static_cast<T*>(&turboModule),
+      count <= 0 ? throw jsi::JSError(rt, "Expected argument in position 0 to be passed") : args[0].asObject(rt).asArray(rt));return jsi::Value::undefined();
+  }
+};
+
+} // namespace facebook::react

package/native/android/CMakeLists.txt

@@ -0,0 +1,8 @@
+cmake_minimum_required(VERSION 3.13)
+project(zyzz)
+
+add_library(react_codegen_ZyzzSpec STATIC ../NativeZyzz.cpp ZyzzSpec-generated.cpp)
+target_include_directories(react_codegen_ZyzzSpec PUBLIC . ..)
+target_link_libraries(react_codegen_ZyzzSpec ReactAndroid::reactnative ReactAndroid::jsi fbjni::fbjni)
+target_compile_features(react_codegen_ZyzzSpec PUBLIC cxx_std_20)
+set_target_properties(react_codegen_ZyzzSpec PROPERTIES POSITION_INDEPENDENT_CODE ON)

package/native/android/ZyzzSpec-generated.cpp

@@ -0,0 +1,50 @@
+
+/**
+ * This code was generated by [react-native-codegen](https://www.npmjs.com/package/react-native-codegen).
+ *
+ * Do not edit this file as changes may cause incorrect behavior and will be lost
+ * once the code is regenerated.
+ *
+ * @generated by codegen project: GenerateModuleJniCpp.js
+ */
+
+#include "ZyzzSpec.h"
+
+namespace facebook::react {
+
+static facebook::jsi::Value __hostFunction_NativeZyzzSpecJSI_attach(facebook::jsi::Runtime& rt, TurboModule &turboModule, const facebook::jsi::Value* args, size_t count) {
+  static jmethodID cachedMethodId = nullptr;
+  return static_cast<JavaTurboModule &>(turboModule).invokeJavaMethod(rt, NumberKind, "attach", "(Lcom/facebook/react/bridge/ReadableMap;Lcom/facebook/react/bridge/ReadableMap;)D", args, count, cachedMethodId);
+}
+
+static facebook::jsi::Value __hostFunction_NativeZyzzSpecJSI_detach(facebook::jsi::Runtime& rt, TurboModule &turboModule, const facebook::jsi::Value* args, size_t count) {
+  static jmethodID cachedMethodId = nullptr;
+  return static_cast<JavaTurboModule &>(turboModule).invokeJavaMethod(rt, VoidKind, "detach", "(D)V", args, count, cachedMethodId);
+}
+
+static facebook::jsi::Value __hostFunction_NativeZyzzSpecJSI_inspect(facebook::jsi::Runtime& rt, TurboModule &turboModule, const facebook::jsi::Value* args, size_t count) {
+  static jmethodID cachedMethodId = nullptr;
+  return static_cast<JavaTurboModule &>(turboModule).invokeJavaMethod(rt, ObjectKind, "inspect", "()Lcom/facebook/react/bridge/WritableMap;", args, count, cachedMethodId);
+}
+
+static facebook::jsi::Value __hostFunction_NativeZyzzSpecJSI_update(facebook::jsi::Runtime& rt, TurboModule &turboModule, const facebook::jsi::Value* args, size_t count) {
+  static jmethodID cachedMethodId = nullptr;
+  return static_cast<JavaTurboModule &>(turboModule).invokeJavaMethod(rt, VoidKind, "update", "(Lcom/facebook/react/bridge/ReadableArray;)V", args, count, cachedMethodId);
+}
+
+NativeZyzzSpecJSI::NativeZyzzSpecJSI(const JavaTurboModule::InitParams &params)
+  : JavaTurboModule(params) {
+  methodMap_["attach"] = MethodMetadata {2, __hostFunction_NativeZyzzSpecJSI_attach};
+  methodMap_["detach"] = MethodMetadata {1, __hostFunction_NativeZyzzSpecJSI_detach};
+  methodMap_["inspect"] = MethodMetadata {0, __hostFunction_NativeZyzzSpecJSI_inspect};
+  methodMap_["update"] = MethodMetadata {1, __hostFunction_NativeZyzzSpecJSI_update};
+}
+
+std::shared_ptr<TurboModule> ZyzzSpec_ModuleProvider(const std::string &moduleName, const JavaTurboModule::InitParams &params) {
+  if (moduleName == "NativeZyzz") {
+    return std::make_shared<NativeZyzzSpecJSI>(params);
+  }
+  return nullptr;
+}
+
+} // namespace facebook::react

package/native/android/ZyzzSpec.h

@@ -0,0 +1,31 @@
+
+/**
+ * This code was generated by [react-native-codegen](https://www.npmjs.com/package/react-native-codegen).
+ *
+ * Do not edit this file as changes may cause incorrect behavior and will be lost
+ * once the code is regenerated.
+ *
+ * @generated by codegen project: GenerateModuleJniH.js
+ */
+
+#pragma once
+
+#include <ReactCommon/JavaTurboModule.h>
+#include <ReactCommon/TurboModule.h>
+#include <jsi/jsi.h>
+
+namespace facebook::react {
+
+/**
+ * JNI C++ class for module 'NativeZyzz'
+ */
+class JSI_EXPORT NativeZyzzSpecJSI : public JavaTurboModule {
+public:
+  NativeZyzzSpecJSI(const JavaTurboModule::InitParams &params);
+};
+
+
+JSI_EXPORT
+std::shared_ptr<TurboModule> ZyzzSpec_ModuleProvider(const std::string &moduleName, const JavaTurboModule::InitParams &params);
+
+} // namespace facebook::react

package/native/ios/ZyzzModuleProvider.mm

@@ -0,0 +1,13 @@
+/** Registers the shared C++ adapter with React Native on iOS. */
+#import <ReactCommon/RCTTurboModule.h>
+#import "NativeZyzz.h"
+
+@interface ZyzzModuleProvider : NSObject <RCTModuleProvider>
+@end
+
+@implementation ZyzzModuleProvider
+- (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:
+    (const facebook::react::ObjCTurboModule::InitParams &)params {
+  return std::make_shared<facebook::react::NativeZyzz>(params.jsInvoker);
+}
+@end

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zyzz",
-  "version": "0.0.21",
+  "version": "0.0.22",
   "license": "MIT",
   "description": "Modern, universal, simple styling library for the Web and React Native",
   "repository": {
@@ -16,6 +16,9 @@
   "files": [
     "dist",
     "src",
+    "native",
+    "react-native.config.ts",
+    "Zyzz.podspec",
     "!src/**/*.bench-d.ts",
     "!src/**/*.bench.ts",
     "!src/**/*.test-d.ts",
@@ -25,6 +28,20 @@
     "./src/reset.css",
     "./dist/reset.css"
   ],
+  "codegenConfig": {
+    "name": "ZyzzSpec",
+    "type": "modules",
+    "jsSrcsDir": "src/react-native/internal",
+    "android": {
+      "javaPackageName": "xyz.wevm.zyzz"
+    },
+    "ios": {
+      "modulesProvider": {
+        "NativeZyzz": "ZyzzModuleProvider"
+      }
+    },
+    "includesGeneratedCode": true
+  },
   "module": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "exports": {
@@ -84,11 +101,24 @@
       "default": "./dist/oxlint/index.js"
     },
     "./react-native": {
+      "react-native": {
+        "types": "./dist/react-native/index.native.d.ts",
+        "default": "./dist/react-native/index.native.js"
+      },
       "src": "./src/react-native/index.ts",
       "types": "./dist/react-native/index.d.ts",
       "default": "./dist/react-native/index.js"
     },
+    "./react-native/reanimated": {
+      "src": "./src/react-native/reanimated.ts",
+      "types": "./dist/react-native/reanimated.d.ts",
+      "default": "./dist/react-native/reanimated.js"
+    },
     "./react-native/react": {
+      "react-native": {
+        "types": "./dist/react-native/react.d.ts",
+        "default": "./dist/react-native/internal/Device.js"
+      },
       "src": "./src/react-native/react.ts",
       "types": "./dist/react-native/react.d.ts",
       "default": "./dist/react-native/react.js"
@@ -146,6 +176,8 @@
     "@babel/core": "^7.29.7",
     "next": "^16.3.5",
     "react": "^19.0.0",
+    "react-native": ">=0.86.0 <1.0.0",
+    "react-native-reanimated": ">=4.5.3 <5.0.0",
     "vite": "^8.0.0"
   },
   "peerDependenciesMeta": {
@@ -158,6 +190,12 @@
     "react": {
       "optional": true
     },
+    "react-native": {
+      "optional": true
+    },
+    "react-native-reanimated": {
+      "optional": true
+    },
     "vite": {
       "optional": true
     }

package/react-native.config.ts

@@ -0,0 +1,14 @@
+/** Autolinks the shared native adapter without application registration. @module */
+export default {
+  dependency: {
+    platforms: {
+      android: {
+        cxxModuleCMakeListsModuleName: 'react_codegen_ZyzzSpec',
+        cxxModuleCMakeListsPath: 'CMakeLists.txt',
+        cxxModuleHeaderName: 'NativeZyzz',
+        sourceDir: 'native/android',
+      },
+      ios: {},
+    },
+  },
+}

package/src/Style.ts

@@ -75,14 +75,17 @@ export type Accepted<
                         ? LiteralDeclarations
                         : DeclarationProperties<tokens>)[key] extends style[key]
                     ? style[key]
-                    : Value.Accepted<
-                        Pick<style, key>,
-                        literal extends true
-                          ? LiteralDeclarations
-                          : DeclarationProperties<tokens>
-                      >[key] &
-                        Value.Checked<Pick<style, key>, tokens>[key] &
-                        Value.Tokens<style[key], tokens, key>
+                    : // Naming the expected tokens avoids a `never` diagnostic and keeps completions to accepted values.
+                      [Value.Tokens<style[key], tokens, key>] extends [never]
+                      ? Value.Mismatch<tokens, key>
+                      : Value.Accepted<
+                          Pick<style, key>,
+                          literal extends true
+                            ? LiteralDeclarations
+                            : DeclarationProperties<tokens>
+                        >[key] &
+                          Value.Checked<Pick<style, key>, tokens>[key] &
+                          Value.Tokens<style[key], tokens, key>
                   : key extends Condition.Keys<tokens, key>
                     ? [style[key]] extends [undefined]
                       ? never