@hanzogui/animation-helpers 8.3.1 → 8.3.2

package/types/normalizeTransition.d.ts

@@ -1,54 +1,53 @@
-import type { AnimationConfig, NormalizedTransition, TransitionPropInput } from "./types";
+import type { AnimationConfig, NormalizedTransition, TransitionPropInput } from './types.ts';
 /**
-* Normalizes the various transition prop formats into a consistent structure.
-*
-* Supported input formats:
-* - String: "bouncy" -> { default: "bouncy", enter: null, exit: null, properties: {} }
-* - Object: { x: 'quick', default: 'slow' } -> { default: "slow", enter: null, exit: null, properties: { x: "quick" } }
-* - Object with enter/exit: { enter: 'bouncy', exit: 'quick' } -> { default: null, enter: "bouncy", exit: "quick", properties: {} }
-* - Array: ['bouncy', { delay: 100, x: 'quick' }] -> { default: "bouncy", enter: null, exit: null, delay: 100, properties: { x: "quick" } }
-*
-* @param transition - The transition prop value in any supported format
-* @returns Normalized transition object with consistent structure
-*/
+ * Normalizes the various transition prop formats into a consistent structure.
+ *
+ * Supported input formats:
+ * - String: "bouncy" -> { default: "bouncy", enter: null, exit: null, properties: {} }
+ * - Object: { x: 'quick', default: 'slow' } -> { default: "slow", enter: null, exit: null, properties: { x: "quick" } }
+ * - Object with enter/exit: { enter: 'bouncy', exit: 'quick' } -> { default: null, enter: "bouncy", exit: "quick", properties: {} }
+ * - Array: ['bouncy', { delay: 100, x: 'quick' }] -> { default: "bouncy", enter: null, exit: null, delay: 100, properties: { x: "quick" } }
+ *
+ * @param transition - The transition prop value in any supported format
+ * @returns Normalized transition object with consistent structure
+ */
 export declare function normalizeTransition(transition: TransitionPropInput): NormalizedTransition;
 /**
-* Gets the animation key for a specific property from a normalized transition.
-* Falls back to the default animation if no property-specific one is defined.
-*
-* @param normalized - The normalized transition object
-* @param property - The property name to get animation for (e.g., 'x', 'opacity')
-* @returns The animation key/config or null if none defined
-*/
+ * Gets the animation key for a specific property from a normalized transition.
+ * Falls back to the default animation if no property-specific one is defined.
+ *
+ * @param normalized - The normalized transition object
+ * @param property - The property name to get animation for (e.g., 'x', 'opacity')
+ * @returns The animation key/config or null if none defined
+ */
 export declare function getAnimationForProperty(normalized: NormalizedTransition, property: string): string | AnimationConfig | null;
 /**
-* Checks if the normalized transition has any animations defined.
-*/
+ * Checks if the normalized transition has any animations defined.
+ */
 export declare function hasAnimation(normalized: NormalizedTransition): boolean;
 /**
-* Gets all property names that have specific animations defined.
-* Does not include 'default' in the list.
-*/
+ * Gets all property names that have specific animations defined.
+ * Does not include 'default' in the list.
+ */
 export declare function getAnimatedProperties(normalized: NormalizedTransition): string[];
 /**
-* Gets the effective animation key based on the current animation state.
-* Priority: enter/exit specific > default > null
-*
-* @param normalized - The normalized transition object
-* @param state - The animation state: 'enter', 'exit', or 'default'
-* @returns The effective animation key or null
-*/
-export declare function getEffectiveAnimation(normalized: NormalizedTransition, state: "enter" | "exit" | "default"): string | null;
+ * Gets the effective animation key based on the current animation state.
+ * Priority: enter/exit specific > default > null
+ *
+ * @param normalized - The normalized transition object
+ * @param state - The animation state: 'enter', 'exit', or 'default'
+ * @returns The effective animation key or null
+ */
+export declare function getEffectiveAnimation(normalized: NormalizedTransition, state: 'enter' | 'exit' | 'default'): string | null;
 /**
-* Gets the resolved animation config for each key, looking up in animations config.
-* Useful for calculating max duration across all animated properties.
-*
-* @param normalized - The normalized transition object
-* @param animations - The animations config object (driver-specific format)
-* @param keys - Property keys to get animations for
-* @param defaultAnimation - The default animation value to fall back to
-* @returns Map of key -> resolved animation config (or null if not found)
-*/
+ * Gets the resolved animation config for each key, looking up in animations config.
+ * Useful for calculating max duration across all animated properties.
+ *
+ * @param normalized - The normalized transition object
+ * @param animations - The animations config object (driver-specific format)
+ * @param keys - Property keys to get animations for
+ * @param defaultAnimation - The default animation value to fall back to
+ * @returns Map of key -> resolved animation config (or null if not found)
+ */
 export declare function getAnimationConfigsForKeys<T>(normalized: NormalizedTransition, animations: Record<string, T>, keys: string[], defaultAnimation: T | null): Map<string, T | null>;
-
 //# sourceMappingURL=normalizeTransition.d.ts.map

package/types/normalizeTransition.d.ts.map

@@ -1,11 +1 @@
-{
-  "mappings": "AAAA,cACE,iBACA,sBAEA,2BACK;;;;;;;;;;;;;AAkCP,OAAO,iBAAS,oBACd,YAAY,sBACX;;;;;;;;;AAqHH,OAAO,iBAAS,wBACd,YAAY,sBACZ,4BACU;;;;AAcZ,OAAO,iBAAS,aAAa,YAAY;;;;;AAazC,OAAO,iBAAS,sBAAsB,YAAY;;;;;;;;;AAYlD,OAAO,iBAAS,sBACd,YAAY,sBACZ,OAAO,UAAU,SAAS;;;;;;;;;;;AAqB5B,OAAO,iBAAS,2BAA2B,GACzC,YAAY,sBACZ,YAAY,eAAe,IAC3B,gBACA,kBAAkB,WACjB,YAAY",
-  "names": [],
-  "sources": [
-    "src/normalizeTransition.ts"
-  ],
-  "version": 3,
-  "sourcesContent": [
-    "import type {\n  AnimationConfig,\n  NormalizedTransition,\n  SpringConfig,\n  TransitionPropInput,\n} from './types'\n\nconst SPRING_CONFIG_KEYS: Set<string> = new Set([\n  'stiffness',\n  'damping',\n  'mass',\n  'tension',\n  'friction',\n  'velocity',\n  'overshootClamping',\n  'duration',\n  'bounciness',\n  'speed',\n])\n\n/**\n * Check if a key is a spring config parameter\n */\nfunction isSpringConfigKey(key: string): key is keyof SpringConfig {\n  return SPRING_CONFIG_KEYS.has(key)\n}\n\n/**\n * Normalizes the various transition prop formats into a consistent structure.\n *\n * Supported input formats:\n * - String: \"bouncy\" -> { default: \"bouncy\", enter: null, exit: null, properties: {} }\n * - Object: { x: 'quick', default: 'slow' } -> { default: \"slow\", enter: null, exit: null, properties: { x: \"quick\" } }\n * - Object with enter/exit: { enter: 'bouncy', exit: 'quick' } -> { default: null, enter: \"bouncy\", exit: \"quick\", properties: {} }\n * - Array: ['bouncy', { delay: 100, x: 'quick' }] -> { default: \"bouncy\", enter: null, exit: null, delay: 100, properties: { x: \"quick\" } }\n *\n * @param transition - The transition prop value in any supported format\n * @returns Normalized transition object with consistent structure\n */\nexport function normalizeTransition(\n  transition: TransitionPropInput\n): NormalizedTransition {\n  // Handle null/undefined\n  if (!transition) {\n    return {\n      default: null,\n      enter: null,\n      exit: null,\n      delay: undefined,\n      properties: {},\n    }\n  }\n\n  // String format: \"bouncy\"\n  if (typeof transition === 'string') {\n    return {\n      default: transition,\n      enter: null,\n      exit: null,\n      delay: undefined,\n      properties: {},\n    }\n  }\n\n  // Array format: ['bouncy', { delay: 100, x: 'quick', enter: 'slow', exit: 'fast' }]\n  // Also supports spring config overrides: ['bouncy', { stiffness: 1000, damping: 70 }]\n  if (Array.isArray(transition)) {\n    const [defaultAnimation, configObj] = transition\n    const properties: Record<string, string | AnimationConfig> = {}\n    const springConfig: SpringConfig = {}\n    let delay: number | undefined\n    let enter: string | null = null\n    let exit: string | null = null\n\n    if (configObj && typeof configObj === 'object') {\n      for (const [key, value] of Object.entries(configObj)) {\n        if (key === 'delay' && typeof value === 'number') {\n          delay = value\n        } else if (key === 'enter' && typeof value === 'string') {\n          enter = value\n        } else if (key === 'exit' && typeof value === 'string') {\n          exit = value\n        } else if (isSpringConfigKey(key) && value !== undefined) {\n          // Spring config override: { stiffness: 1000, damping: 70 }\n          springConfig[key] = value as SpringConfig[keyof SpringConfig]\n        } else if (value !== undefined) {\n          // Property-specific animation: string or config object\n          properties[key] = value as string | AnimationConfig\n        }\n      }\n    }\n\n    return {\n      default: defaultAnimation,\n      enter,\n      exit,\n      delay,\n      properties,\n      config: Object.keys(springConfig).length > 0 ? springConfig : undefined,\n    }\n  }\n\n  // Object format: { x: 'quick', y: 'bouncy', default: 'slow', enter: 'bouncy', exit: 'quick' }\n  // Also supports spring config overrides: { default: 'bouncy', stiffness: 1000 }\n  if (typeof transition === 'object') {\n    const properties: Record<string, string | AnimationConfig> = {}\n    const springConfig: SpringConfig = {}\n    let defaultAnimation: string | null = null\n    let enter: string | null = null\n    let exit: string | null = null\n    let delay: number | undefined\n\n    for (const [key, value] of Object.entries(transition)) {\n      if (key === 'default' && typeof value === 'string') {\n        defaultAnimation = value\n      } else if (key === 'enter' && typeof value === 'string') {\n        enter = value\n      } else if (key === 'exit' && typeof value === 'string') {\n        exit = value\n      } else if (key === 'delay' && typeof value === 'number') {\n        delay = value\n      } else if (isSpringConfigKey(key) && value !== undefined) {\n        // Spring config override: { stiffness: 1000, damping: 70 }\n        springConfig[key] = value as SpringConfig[keyof SpringConfig]\n      } else if (value !== undefined) {\n        // Property-specific animation: string or config object\n        properties[key] = value as string | AnimationConfig\n      }\n    }\n\n    return {\n      default: defaultAnimation,\n      enter,\n      exit,\n      delay,\n      properties,\n      config: Object.keys(springConfig).length > 0 ? springConfig : undefined,\n    }\n  }\n\n  // Fallback\n  return {\n    default: null,\n    enter: null,\n    exit: null,\n    delay: undefined,\n    properties: {},\n  }\n}\n\n/**\n * Gets the animation key for a specific property from a normalized transition.\n * Falls back to the default animation if no property-specific one is defined.\n *\n * @param normalized - The normalized transition object\n * @param property - The property name to get animation for (e.g., 'x', 'opacity')\n * @returns The animation key/config or null if none defined\n */\nexport function getAnimationForProperty(\n  normalized: NormalizedTransition,\n  property: string\n): string | AnimationConfig | null {\n  // Check for property-specific animation\n  const propertyAnimation = normalized.properties[property]\n  if (propertyAnimation !== undefined) {\n    return propertyAnimation\n  }\n\n  // Fall back to default\n  return normalized.default\n}\n\n/**\n * Checks if the normalized transition has any animations defined.\n */\nexport function hasAnimation(normalized: NormalizedTransition): boolean {\n  return (\n    normalized.default !== null ||\n    normalized.enter !== null ||\n    normalized.exit !== null ||\n    Object.keys(normalized.properties).length > 0\n  )\n}\n\n/**\n * Gets all property names that have specific animations defined.\n * Does not include 'default' in the list.\n */\nexport function getAnimatedProperties(normalized: NormalizedTransition): string[] {\n  return Object.keys(normalized.properties)\n}\n\n/**\n * Gets the effective animation key based on the current animation state.\n * Priority: enter/exit specific > default > null\n *\n * @param normalized - The normalized transition object\n * @param state - The animation state: 'enter', 'exit', or 'default'\n * @returns The effective animation key or null\n */\nexport function getEffectiveAnimation(\n  normalized: NormalizedTransition,\n  state: 'enter' | 'exit' | 'default'\n): string | null {\n  if (state === 'enter' && normalized.enter) {\n    return normalized.enter\n  }\n  if (state === 'exit' && normalized.exit) {\n    return normalized.exit\n  }\n  return normalized.default\n}\n\n/**\n * Gets the resolved animation config for each key, looking up in animations config.\n * Useful for calculating max duration across all animated properties.\n *\n * @param normalized - The normalized transition object\n * @param animations - The animations config object (driver-specific format)\n * @param keys - Property keys to get animations for\n * @param defaultAnimation - The default animation value to fall back to\n * @returns Map of key -> resolved animation config (or null if not found)\n */\nexport function getAnimationConfigsForKeys<T>(\n  normalized: NormalizedTransition,\n  animations: Record<string, T>,\n  keys: string[],\n  defaultAnimation: T | null\n): Map<string, T | null> {\n  const result = new Map<string, T | null>()\n\n  for (const key of keys) {\n    const propAnimation = normalized.properties[key]\n    let animationValue: T | null = null\n\n    if (typeof propAnimation === 'string') {\n      animationValue = animations[propAnimation] ?? null\n    } else if (\n      propAnimation &&\n      typeof propAnimation === 'object' &&\n      (propAnimation as any).type\n    ) {\n      animationValue = animations[(propAnimation as any).type] ?? null\n    }\n\n    // fall back to default if no per-property config found\n    if (animationValue === null) {\n      animationValue = defaultAnimation\n    }\n\n    result.set(key, animationValue)\n  }\n\n  return result\n}\n"
-  ]
-}
+{"version":3,"file":"normalizeTransition.d.ts","sourceRoot":"","sources":["../src/normalizeTransition.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,eAAe,EACf,oBAAoB,EAEpB,mBAAmB,EACpB,MAAM,YAAY,CAAA;AAsBnB;;;;;;;;;;;GAWG;AACH,wBAAgB,mBAAmB,CACjC,UAAU,EAAE,mBAAmB,GAC9B,oBAAoB,CA2GtB;AAED;;;;;;;GAOG;AACH,wBAAgB,uBAAuB,CACrC,UAAU,EAAE,oBAAoB,EAChC,QAAQ,EAAE,MAAM,GACf,MAAM,GAAG,eAAe,GAAG,IAAI,CASjC;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,UAAU,EAAE,oBAAoB,GAAG,OAAO,CAOtE;AAED;;;GAGG;AACH,wBAAgB,qBAAqB,CAAC,UAAU,EAAE,oBAAoB,GAAG,MAAM,EAAE,CAEhF;AAED;;;;;;;GAOG;AACH,wBAAgB,qBAAqB,CACnC,UAAU,EAAE,oBAAoB,EAChC,KAAK,EAAE,OAAO,GAAG,MAAM,GAAG,SAAS,GAClC,MAAM,GAAG,IAAI,CAQf;AAED;;;;;;;;;GASG;AACH,wBAAgB,0BAA0B,CAAC,CAAC,EAC1C,UAAU,EAAE,oBAAoB,EAChC,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,EAC7B,IAAI,EAAE,MAAM,EAAE,EACd,gBAAgB,EAAE,CAAC,GAAG,IAAI,GACzB,GAAG,CAAC,MAAM,EAAE,CAAC,GAAG,IAAI,CAAC,CA0BvB"}

package/types/types.d.ts

@@ -1,56 +1,55 @@
 /**
-* Animation configuration that can include additional properties
-* like delay, duration, stiffness, damping, etc.
-*/
+ * Animation configuration that can include additional properties
+ * like delay, duration, stiffness, damping, etc.
+ */
 export type AnimationConfig = {
-	type?: string;
-	[key: string]: any;
+    type?: string;
+    [key: string]: any;
 };
 /**
-* Input format for the transition prop - supports multiple syntaxes:
-*
-* 1. String: "bouncy"
-* 2. Object with property mappings: { x: 'quick', y: 'bouncy', default: 'slow' }
-* 3. Array with config: ['bouncy', { delay: 100, x: 'quick' }]
-* 4. Object with enter/exit: { enter: 'bouncy', exit: 'quick', default: 'slow' }
-*
-* Note: Uses `any` to be compatible with the TransitionProp type from @hanzogui/web
-* which has more complex union types.
-*/
+ * Input format for the transition prop - supports multiple syntaxes:
+ *
+ * 1. String: "bouncy"
+ * 2. Object with property mappings: { x: 'quick', y: 'bouncy', default: 'slow' }
+ * 3. Array with config: ['bouncy', { delay: 100, x: 'quick' }]
+ * 4. Object with enter/exit: { enter: 'bouncy', exit: 'quick', default: 'slow' }
+ *
+ * Note: Uses `any` to be compatible with the TransitionProp type from @hanzogui/web
+ * which has more complex union types.
+ */
 export type TransitionPropInput = any;
 /**
-* Spring configuration parameters that can override preset defaults.
-* These are the common parameters across animation drivers.
-*/
+ * Spring configuration parameters that can override preset defaults.
+ * These are the common parameters across animation drivers.
+ */
 export type SpringConfig = {
-	stiffness?: number;
-	damping?: number;
-	mass?: number;
-	tension?: number;
-	friction?: number;
-	velocity?: number;
-	overshootClamping?: boolean;
-	duration?: number;
-	bounciness?: number;
-	speed?: number;
+    stiffness?: number;
+    damping?: number;
+    mass?: number;
+    tension?: number;
+    friction?: number;
+    velocity?: number;
+    overshootClamping?: boolean;
+    duration?: number;
+    bounciness?: number;
+    speed?: number;
 };
 /**
-* Normalized output format that all animation drivers consume.
-* Provides a consistent structure regardless of input format.
-*/
+ * Normalized output format that all animation drivers consume.
+ * Provides a consistent structure regardless of input format.
+ */
 export type NormalizedTransition = {
-	/** Default animation key for properties not explicitly listed */
-	default: string | null;
-	/** Animation key to use during enter transitions (mount) */
-	enter: string | null;
-	/** Animation key to use during exit transitions (unmount) */
-	exit: string | null;
-	/** Global delay in ms */
-	delay: number | undefined;
-	/** Per-property animation configs: propertyName -> animationKey or config */
-	properties: Record<string, string | AnimationConfig>;
-	/** Global spring config overrides that merge with the preset defaults */
-	config?: SpringConfig;
+    /** Default animation key for properties not explicitly listed */
+    default: string | null;
+    /** Animation key to use during enter transitions (mount) */
+    enter: string | null;
+    /** Animation key to use during exit transitions (unmount) */
+    exit: string | null;
+    /** Global delay in ms */
+    delay: number | undefined;
+    /** Per-property animation configs: propertyName -> animationKey or config */
+    properties: Record<string, string | AnimationConfig>;
+    /** Global spring config overrides that merge with the preset defaults */
+    config?: SpringConfig;
 };
-
 //# sourceMappingURL=types.d.ts.map

package/types/types.d.ts.map

@@ -1,11 +1 @@
-{
-  "mappings": ";;;;AAIA,YAAY,kBAAkB;CAC5B;;;;;;;;;;;;;;AAeF,YAAY;;;;;AAMZ,YAAY,eAAe;CACzB;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;;;;;;AAOF,YAAY,uBAAuB;;CAEjC;;CAEA;;CAEA;;CAEA;;CAEA,YAAY,wBAAwB;;CAEpC,SAAS",
-  "names": [],
-  "sources": [
-    "src/types.ts"
-  ],
-  "version": 3,
-  "sourcesContent": [
-    "/**\n * Animation configuration that can include additional properties\n * like delay, duration, stiffness, damping, etc.\n */\nexport type AnimationConfig = {\n  type?: string\n  [key: string]: any\n}\n\n/**\n * Input format for the transition prop - supports multiple syntaxes:\n *\n * 1. String: \"bouncy\"\n * 2. Object with property mappings: { x: 'quick', y: 'bouncy', default: 'slow' }\n * 3. Array with config: ['bouncy', { delay: 100, x: 'quick' }]\n * 4. Object with enter/exit: { enter: 'bouncy', exit: 'quick', default: 'slow' }\n *\n * Note: Uses `any` to be compatible with the TransitionProp type from @hanzogui/web\n * which has more complex union types.\n */\nexport type TransitionPropInput = any\n\n/**\n * Spring configuration parameters that can override preset defaults.\n * These are the common parameters across animation drivers.\n */\nexport type SpringConfig = {\n  stiffness?: number\n  damping?: number\n  mass?: number\n  tension?: number\n  friction?: number\n  velocity?: number\n  overshootClamping?: boolean\n  duration?: number\n  bounciness?: number\n  speed?: number\n}\n\n/**\n * Normalized output format that all animation drivers consume.\n * Provides a consistent structure regardless of input format.\n */\nexport type NormalizedTransition = {\n  /** Default animation key for properties not explicitly listed */\n  default: string | null\n  /** Animation key to use during enter transitions (mount) */\n  enter: string | null\n  /** Animation key to use during exit transitions (unmount) */\n  exit: string | null\n  /** Global delay in ms */\n  delay: number | undefined\n  /** Per-property animation configs: propertyName -> animationKey or config */\n  properties: Record<string, string | AnimationConfig>\n  /** Global spring config overrides that merge with the preset defaults */\n  config?: SpringConfig\n}\n"
-  ]
-}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,MAAM,MAAM,eAAe,GAAG;IAC5B,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAA;CACnB,CAAA;AAED;;;;;;;;;;GAUG;AACH,MAAM,MAAM,mBAAmB,GAAG,GAAG,CAAA;AAErC;;;GAGG;AACH,MAAM,MAAM,YAAY,GAAG;IACzB,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,iBAAiB,CAAC,EAAE,OAAO,CAAA;IAC3B,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,KAAK,CAAC,EAAE,MAAM,CAAA;CACf,CAAA;AAED;;;GAGG;AACH,MAAM,MAAM,oBAAoB,GAAG;IACjC,iEAAiE;IACjE,OAAO,EAAE,MAAM,GAAG,IAAI,CAAA;IACtB,4DAA4D;IAC5D,KAAK,EAAE,MAAM,GAAG,IAAI,CAAA;IACpB,6DAA6D;IAC7D,IAAI,EAAE,MAAM,GAAG,IAAI,CAAA;IACnB,yBAAyB;IACzB,KAAK,EAAE,MAAM,GAAG,SAAS,CAAA;IACzB,6EAA6E;IAC7E,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,eAAe,CAAC,CAAA;IACpD,yEAAyE;IACzE,MAAM,CAAC,EAAE,YAAY,CAAA;CACtB,CAAA"}

package/dist/cjs/index.cjs

@@ -1,33 +0,0 @@
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all) __defProp(target, name, {
-    get: all[name],
-    enumerable: true
-  });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from)) if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
-      get: () => from[key],
-      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-    });
-  }
-  return to;
-};
-var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
-  value: true
-}), mod);
-var index_exports = {};
-__export(index_exports, {
-  getAnimatedProperties: () => import_normalizeTransition.getAnimatedProperties,
-  getAnimationConfigsForKeys: () => import_normalizeTransition.getAnimationConfigsForKeys,
-  getAnimationForProperty: () => import_normalizeTransition.getAnimationForProperty,
-  getEffectiveAnimation: () => import_normalizeTransition.getEffectiveAnimation,
-  hasAnimation: () => import_normalizeTransition.hasAnimation,
-  normalizeTransition: () => import_normalizeTransition.normalizeTransition
-});
-module.exports = __toCommonJS(index_exports);
-var import_normalizeTransition = require("./normalizeTransition.cjs");

package/dist/cjs/index.native.js

@@ -1,36 +0,0 @@
-"use strict";
-
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all) __defProp(target, name, {
-    get: all[name],
-    enumerable: true
-  });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from)) if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
-      get: () => from[key],
-      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-    });
-  }
-  return to;
-};
-var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
-  value: true
-}), mod);
-var index_exports = {};
-__export(index_exports, {
-  getAnimatedProperties: () => import_normalizeTransition.getAnimatedProperties,
-  getAnimationConfigsForKeys: () => import_normalizeTransition.getAnimationConfigsForKeys,
-  getAnimationForProperty: () => import_normalizeTransition.getAnimationForProperty,
-  getEffectiveAnimation: () => import_normalizeTransition.getEffectiveAnimation,
-  hasAnimation: () => import_normalizeTransition.hasAnimation,
-  normalizeTransition: () => import_normalizeTransition.normalizeTransition
-});
-module.exports = __toCommonJS(index_exports);
-var import_normalizeTransition = require("./normalizeTransition.native.js");
-//# sourceMappingURL=index.native.js.map

package/dist/cjs/index.native.js.map

@@ -1 +0,0 @@
-{"version":3,"names":["__toCommonJS","mod","__copyProps","__defProp","value","index_exports","__export","getAnimatedProperties","import_normalizeTransition","getAnimationConfigsForKeys","getAnimationForProperty","getEffectiveAnimation","hasAnimation","normalizeTransition","module","exports"],"sources":["../../src/index.ts"],"sourcesContent":[null],"mappings":";;;;;;;;;;;;;;;;;;;;;AAAA,IAAAA,YAAA,GAAAC,GAAA,IAAAC,WAAA,CAAAC,SAAA;EAAAC,KAAA;AAAA,IAAAH,GAAA;AAAA,IAAAI,aAAA;AAAAC,QAAA,CAAAD,aAAA;EAAAE,qBAAA,EAAAA,CAAA,KAAAC,0BAAA,CAAAD,qBAAA;EAAAE,0BAAA,EAAAA,CAAA,KAAAD,0BAAA,CAAAC,0BAAA;EAAAC,uBAAA,EAAAA,CAAA,KAAAF,0BAAA,CAAAE,uBAAA;EAAAC,qBAAA,EAAAA,CAAA,KAAAH,0BAAA,CAAAG,qBAAA;EAAAC,YAAA,EAAAA,CAAA,KAAAJ,0BAAA,CAAAI,YAAA;EAAAC,mBAAA,EAAAA,CAAA,KAAAL,0BAAA,CAAAK;AAAA;AAAAC,MAAA,CAAAC,OAAA,GAAAf,YAAA,CAAAK,aAOO","ignoreList":[]}

package/dist/cjs/normalizeTransition.cjs

@@ -1,164 +0,0 @@
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all) __defProp(target, name, {
-    get: all[name],
-    enumerable: true
-  });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from)) if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
-      get: () => from[key],
-      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-    });
-  }
-  return to;
-};
-var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
-  value: true
-}), mod);
-var normalizeTransition_exports = {};
-__export(normalizeTransition_exports, {
-  getAnimatedProperties: () => getAnimatedProperties,
-  getAnimationConfigsForKeys: () => getAnimationConfigsForKeys,
-  getAnimationForProperty: () => getAnimationForProperty,
-  getEffectiveAnimation: () => getEffectiveAnimation,
-  hasAnimation: () => hasAnimation,
-  normalizeTransition: () => normalizeTransition
-});
-module.exports = __toCommonJS(normalizeTransition_exports);
-const SPRING_CONFIG_KEYS = /* @__PURE__ */new Set(["stiffness", "damping", "mass", "tension", "friction", "velocity", "overshootClamping", "duration", "bounciness", "speed"]);
-function isSpringConfigKey(key) {
-  return SPRING_CONFIG_KEYS.has(key);
-}
-function normalizeTransition(transition) {
-  if (!transition) {
-    return {
-      default: null,
-      enter: null,
-      exit: null,
-      delay: void 0,
-      properties: {}
-    };
-  }
-  if (typeof transition === "string") {
-    return {
-      default: transition,
-      enter: null,
-      exit: null,
-      delay: void 0,
-      properties: {}
-    };
-  }
-  if (Array.isArray(transition)) {
-    const [defaultAnimation, configObj] = transition;
-    const properties = {};
-    const springConfig = {};
-    let delay;
-    let enter = null;
-    let exit = null;
-    if (configObj && typeof configObj === "object") {
-      for (const [key, value] of Object.entries(configObj)) {
-        if (key === "delay" && typeof value === "number") {
-          delay = value;
-        } else if (key === "enter" && typeof value === "string") {
-          enter = value;
-        } else if (key === "exit" && typeof value === "string") {
-          exit = value;
-        } else if (isSpringConfigKey(key) && value !== void 0) {
-          springConfig[key] = value;
-        } else if (value !== void 0) {
-          properties[key] = value;
-        }
-      }
-    }
-    return {
-      default: defaultAnimation,
-      enter,
-      exit,
-      delay,
-      properties,
-      config: Object.keys(springConfig).length > 0 ? springConfig : void 0
-    };
-  }
-  if (typeof transition === "object") {
-    const properties = {};
-    const springConfig = {};
-    let defaultAnimation = null;
-    let enter = null;
-    let exit = null;
-    let delay;
-    for (const [key, value] of Object.entries(transition)) {
-      if (key === "default" && typeof value === "string") {
-        defaultAnimation = value;
-      } else if (key === "enter" && typeof value === "string") {
-        enter = value;
-      } else if (key === "exit" && typeof value === "string") {
-        exit = value;
-      } else if (key === "delay" && typeof value === "number") {
-        delay = value;
-      } else if (isSpringConfigKey(key) && value !== void 0) {
-        springConfig[key] = value;
-      } else if (value !== void 0) {
-        properties[key] = value;
-      }
-    }
-    return {
-      default: defaultAnimation,
-      enter,
-      exit,
-      delay,
-      properties,
-      config: Object.keys(springConfig).length > 0 ? springConfig : void 0
-    };
-  }
-  return {
-    default: null,
-    enter: null,
-    exit: null,
-    delay: void 0,
-    properties: {}
-  };
-}
-function getAnimationForProperty(normalized, property) {
-  const propertyAnimation = normalized.properties[property];
-  if (propertyAnimation !== void 0) {
-    return propertyAnimation;
-  }
-  return normalized.default;
-}
-function hasAnimation(normalized) {
-  return normalized.default !== null || normalized.enter !== null || normalized.exit !== null || Object.keys(normalized.properties).length > 0;
-}
-function getAnimatedProperties(normalized) {
-  return Object.keys(normalized.properties);
-}
-function getEffectiveAnimation(normalized, state) {
-  if (state === "enter" && normalized.enter) {
-    return normalized.enter;
-  }
-  if (state === "exit" && normalized.exit) {
-    return normalized.exit;
-  }
-  return normalized.default;
-}
-function getAnimationConfigsForKeys(normalized, animations, keys, defaultAnimation) {
-  const result = /* @__PURE__ */new Map();
-  for (const key of keys) {
-    const propAnimation = normalized.properties[key];
-    let animationValue = null;
-    if (typeof propAnimation === "string") {
-      animationValue = animations[propAnimation] ?? null;
-    } else if (propAnimation && typeof propAnimation === "object" && propAnimation.type) {
-      animationValue = animations[propAnimation.type] ?? null;
-    }
-    if (animationValue === null) {
-      animationValue = defaultAnimation;
-    }
-    result.set(key, animationValue);
-  }
-  return result;
-}