@idealyst/theme 1.2.103 → 1.2.104

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@idealyst/theme",
-  "version": "1.2.103",
+  "version": "1.2.104",
   "description": "Theming system for Idealyst Framework",
   "readme": "README.md",
   "main": "src/index.ts",
@@ -63,7 +63,7 @@
     "publish:npm": "npm publish"
   },
   "dependencies": {
-    "@idealyst/tooling": "^1.2.103"
+    "@idealyst/tooling": "^1.2.104"
   },
   "peerDependencies": {
     "react-native-unistyles": ">=3.0.0"

package/src/babel/plugin.js

@@ -126,11 +126,42 @@ function mergeObjectExpressions(t, target, source) {
                 const idx = resultProps.indexOf(existingProp);
                 resultProps[idx] = t.objectProperty(existingProp.key, mergedValue);
             }
-            // If both are arrow functions (dynamic styles), merge their return values
-            else if (t.isArrowFunctionExpression(existingValue) && t.isArrowFunctionExpression(newValue)) {
-                const mergedFn = mergeDynamicStyleFunctions(t, existingValue, newValue);
-                const idx = resultProps.indexOf(existingProp);
-                resultProps[idx] = t.objectProperty(existingProp.key, mergedFn);
+            // If base is a dynamic function and extension is anything (plain object
+            // or arrow function), extract the extension's object and merge it into the
+            // base function's return body. Extensions should only provide plain objects,
+            // but if a function is given we unwrap its body to get the object.
+            else if (t.isArrowFunctionExpression(existingValue)) {
+                let extObj = newValue;
+                // If extension mistakenly provides a function, unwrap its return body
+                if (t.isArrowFunctionExpression(extObj)) {
+                    extObj = extObj.body;
+                    if (t.isParenthesizedExpression(extObj)) {
+                        extObj = extObj.expression;
+                    }
+                }
+
+                if (t.isObjectExpression(extObj)) {
+                    let baseBody = existingValue.body;
+                    if (t.isParenthesizedExpression(baseBody)) {
+                        baseBody = baseBody.expression;
+                    }
+                    if (t.isObjectExpression(baseBody)) {
+                        const mergedBody = mergeObjectExpressions(t, baseBody, extObj);
+                        const idx = resultProps.indexOf(existingProp);
+                        resultProps[idx] = t.objectProperty(
+                            existingProp.key,
+                            t.arrowFunctionExpression(existingValue.params, mergedBody)
+                        );
+                    } else {
+                        // Block body or other complex form — fall back to replacement
+                        const idx = resultProps.indexOf(existingProp);
+                        resultProps[idx] = prop;
+                    }
+                } else {
+                    // Extension body isn't an object — fall back to replacement
+                    const idx = resultProps.indexOf(existingProp);
+                    resultProps[idx] = prop;
+                }
             }
             // Otherwise, source replaces target
             else {
@@ -188,33 +219,6 @@ function mergeObjectExpressions(t, target, source) {
     return t.objectExpression(resultProps);
 }
 
-/**
- * Merge two dynamic style functions (arrow functions that return style objects).
- * Creates a new function that merges both return values.
- */
-function mergeDynamicStyleFunctions(t, baseFn, extFn) {
-    // Get the bodies (assuming they return ObjectExpressions)
-    let baseBody = baseFn.body;
-    let extBody = extFn.body;
-
-    // Handle parenthesized expressions
-    if (t.isParenthesizedExpression(baseBody)) {
-        baseBody = baseBody.expression;
-    }
-    if (t.isParenthesizedExpression(extBody)) {
-        extBody = extBody.expression;
-    }
-
-    // If both return ObjectExpressions directly, merge them
-    if (t.isObjectExpression(baseBody) && t.isObjectExpression(extBody)) {
-        const mergedBody = mergeObjectExpressions(t, baseBody, extBody);
-        return t.arrowFunctionExpression(baseFn.params, mergedBody);
-    }
-
-    // For block statements, this is more complex - just use extension for now
-    return extFn;
-}
-
 /**
  * Merge a callback body (the object returned by theme => ({ ... }))
  */

package/src/componentStyles.ts

@@ -22,10 +22,12 @@ import type { TextStyle, ViewStyle } from 'react-native';
 /**
  * Registry interface that components augment to register their style types.
  * This enables type-safe extendStyle and overrideStyle calls.
+ *
+ * Style definitions must use plain style objects, not functions.
  */
 export interface ComponentStyleRegistry {
   // Components augment this interface to add their style types
-  // Example: Text: { text: (params: TextStyleParams) => TextStyleObject }
+  // Example: Text: { text: TextStyle & { variants?: { ... } } }
 }
 
 /**
@@ -37,38 +39,25 @@ export type ComponentStyleDef<K extends string> = K extends keyof ComponentStyle
   : Record<string, any>;
 
 /**
- * Deep partial type that works with functions.
- * For style functions, preserves the function signature but makes the return type partial.
+ * Deep partial type for style objects.
+ * Recursively makes all properties optional.
+ * Extensions must be plain style objects — functions are not supported.
  */
-export type DeepPartialStyle<T> = T extends (...args: infer A) => infer R
-  ? (...args: A) => DeepPartialStyle<R>
-  : T extends object
-    ? { [K in keyof T]?: DeepPartialStyle<T[K]> }
-    : T;
+export type DeepPartialStyle<T> = T extends object
+  ? { [K in keyof T]?: DeepPartialStyle<T[K]> }
+  : T;
 
 /**
- * Style definition for extendStyle - requires functions with same params as base.
- * All style properties must be functions to access dynamic params.
+ * Style definition for extendStyle - plain style objects only.
+ * Functions are not supported; the babel plugin merges plain objects into base styles.
  */
 export type ExtendStyleDef<K extends string> = DeepPartialStyle<ComponentStyleDef<K>>;
 
 /**
- * Style definition for overrideStyle - requires full implementation with functions.
+ * Style definition for overrideStyle - requires full style implementation.
  */
 export type OverrideStyleDef<K extends string> = ComponentStyleDef<K>;
 
-/**
- * Helper to extract the params type from a dynamic style function.
- * Use this to type your extension functions.
- *
- * @example
- * ```typescript
- * type TextParams = StyleParams<TextStyleDef['text']>;
- * // TextParams = { color?: TextColorVariant }
- * ```
- */
-export type StyleParams<T> = T extends (params: infer P) => any ? P : never;
-
 // =============================================================================
 // Common Style Types
 // =============================================================================
@@ -86,8 +75,3 @@ export interface StyleWithVariants<TVariants extends Record<string, any> = Recor
     [K in keyof TVariants]?: TVariants[K];
   } & { styles: ViewStyle | TextStyle }>;
 }
-
-/**
- * Dynamic style function type.
- */
-export type DynamicStyleFn<TParams, TStyle> = (params: TParams) => TStyle;