@hanzogui/react-native-web-lite 2.0.0-rc.41-hanzoai.5

package/dist/cjs/vendor/react-native/Animated/nodes/AnimatedProps.cjs

@@ -0,0 +1,151 @@
+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 AnimatedProps_exports = {};
+__export(AnimatedProps_exports, {
+  AnimatedProps: () => AnimatedProps,
+  default: () => AnimatedProps_default
+});
+module.exports = __toCommonJS(AnimatedProps_exports);
+var import_AnimatedEvent = require("../AnimatedEvent.cjs");
+var import_AnimatedNode = require("./AnimatedNode.cjs");
+var import_AnimatedStyle = require("./AnimatedStyle.cjs");
+var import_NativeAnimatedHelper = require("../NativeAnimatedHelper.cjs");
+var import_react_native_web_internals = require("@hanzogui/react-native-web-internals");
+class AnimatedProps extends import_AnimatedNode.AnimatedNode {
+  constructor(props, callback) {
+    super();
+    if (props.style) {
+      props = {
+        ...props,
+        style: new import_AnimatedStyle.AnimatedStyle(props.style)
+      };
+    }
+    this._props = props;
+    this._callback = callback;
+    this.__attach();
+  }
+  __getValue() {
+    const props = {};
+    for (const key in this._props) {
+      const value = this._props[key];
+      if (value instanceof import_AnimatedNode.AnimatedNode) {
+        if (!value.__isNative || value instanceof import_AnimatedStyle.AnimatedStyle) {
+          props[key] = value.__getValue();
+        }
+      } else if (value instanceof import_AnimatedEvent.AnimatedEvent) {
+        props[key] = value.__getHandler();
+      } else {
+        props[key] = value;
+      }
+    }
+    return props;
+  }
+  __getAnimatedValue() {
+    const props = {};
+    for (const key in this._props) {
+      const value = this._props[key];
+      if (value instanceof import_AnimatedNode.AnimatedNode) {
+        props[key] = value.__getAnimatedValue();
+      }
+    }
+    return props;
+  }
+  __attach() {
+    for (const key in this._props) {
+      const value = this._props[key];
+      if (value instanceof import_AnimatedNode.AnimatedNode) {
+        value.__addChild(this);
+      }
+    }
+  }
+  __detach() {
+    if (this.__isNative && this._animatedView) {
+      this.__disconnectAnimatedView();
+    }
+    for (const key in this._props) {
+      const value = this._props[key];
+      if (value instanceof import_AnimatedNode.AnimatedNode) {
+        value.__removeChild(this);
+      }
+    }
+    super.__detach();
+  }
+  update() {
+    this._callback();
+  }
+  __makeNative() {
+    if (!this.__isNative) {
+      this.__isNative = true;
+      for (const key in this._props) {
+        const value = this._props[key];
+        if (value instanceof import_AnimatedNode.AnimatedNode) {
+          value.__makeNative();
+        }
+      }
+      if (this._animatedView) {
+        this.__connectAnimatedView();
+      }
+    }
+  }
+  setNativeView(animatedView) {
+    if (this._animatedView === animatedView) {
+      return;
+    }
+    this._animatedView = animatedView;
+    if (this.__isNative) {
+      this.__connectAnimatedView();
+    }
+  }
+  __connectAnimatedView() {
+    (0, import_react_native_web_internals.invariant)(this.__isNative, 'Expected node to be marked as "native"');
+    const nativeViewTag = this._animatedView;
+    (0, import_react_native_web_internals.invariant)(nativeViewTag != null, "Unable to locate attached view in the native tree");
+    import_NativeAnimatedHelper.NativeAnimatedHelper.API.connectAnimatedNodeToView(this.__getNativeTag(), nativeViewTag);
+  }
+  __disconnectAnimatedView() {
+    (0, import_react_native_web_internals.invariant)(this.__isNative, 'Expected node to be marked as "native"');
+    const nativeViewTag = this._animatedView;
+    (0, import_react_native_web_internals.invariant)(nativeViewTag != null, "Unable to locate attached view in the native tree");
+    import_NativeAnimatedHelper.NativeAnimatedHelper.API.disconnectAnimatedNodeFromView(this.__getNativeTag(), nativeViewTag);
+  }
+  __restoreDefaultValues() {
+    if (this.__isNative) {
+      import_NativeAnimatedHelper.NativeAnimatedHelper.API.restoreDefaultValues(this.__getNativeTag());
+    }
+  }
+  __getNativeConfig() {
+    const propsConfig = {};
+    for (const propKey in this._props) {
+      const value = this._props[propKey];
+      if (value instanceof import_AnimatedNode.AnimatedNode) {
+        value.__makeNative();
+        propsConfig[propKey] = value.__getNativeTag();
+      }
+    }
+    return {
+      type: "props",
+      props: propsConfig
+    };
+  }
+}
+var AnimatedProps_default = AnimatedProps;

package/dist/cjs/vendor/react-native/Animated/nodes/AnimatedStyle.cjs

@@ -0,0 +1,136 @@
+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 AnimatedStyle_exports = {};
+__export(AnimatedStyle_exports, {
+  AnimatedStyle: () => AnimatedStyle,
+  default: () => AnimatedStyle_default
+});
+module.exports = __toCommonJS(AnimatedStyle_exports);
+var import_AnimatedNode = require("./AnimatedNode.cjs");
+var import_AnimatedTransform = require("./AnimatedTransform.cjs");
+var import_AnimatedWithChildren = require("./AnimatedWithChildren.cjs");
+var import_NativeAnimatedHelper = require("../NativeAnimatedHelper.cjs");
+var import_react_native_web_internals = require("@hanzogui/react-native-web-internals");
+const flattenStyle = import_react_native_web_internals.StyleSheet.flatten;
+function createAnimatedStyle(inputStyle) {
+  const style = flattenStyle(inputStyle);
+  const animatedStyles = {};
+  for (const key in style) {
+    const value = style[key];
+    if (key === "transform" && Array.isArray(value)) {
+      animatedStyles[key] = new import_AnimatedTransform.AnimatedTransform(value);
+    } else if (value instanceof import_AnimatedNode.AnimatedNode) {
+      animatedStyles[key] = value;
+    } else if (value && !Array.isArray(value) && typeof value === "object") {
+      animatedStyles[key] = createAnimatedStyle(value);
+    }
+  }
+  return animatedStyles;
+}
+class AnimatedStyle extends import_AnimatedWithChildren.AnimatedWithChildren {
+  _inputStyle;
+  _style;
+  constructor(style) {
+    super();
+    this._inputStyle = style;
+    this._style = createAnimatedStyle(style);
+  }
+  // Recursively get values for nested styles (like iOS's shadowOffset)
+  _walkStyleAndGetValues(style) {
+    const updatedStyle = {};
+    for (const key in style) {
+      const value = style[key];
+      if (value instanceof import_AnimatedNode.AnimatedNode) {
+        if (!value.__isNative) {
+          updatedStyle[key] = value.__getValue();
+        }
+      } else if (value && !Array.isArray(value) && typeof value === "object") {
+        updatedStyle[key] = this._walkStyleAndGetValues(value);
+      } else {
+        updatedStyle[key] = value;
+      }
+    }
+    return updatedStyle;
+  }
+  __getValue() {
+    return [this._inputStyle, this._walkStyleAndGetValues(this._style)];
+  }
+  // Recursively get animated values for nested styles (like iOS's shadowOffset)
+  _walkStyleAndGetAnimatedValues(style) {
+    const updatedStyle = {};
+    for (const key in style) {
+      const value = style[key];
+      if (value instanceof import_AnimatedNode.AnimatedNode) {
+        updatedStyle[key] = value.__getAnimatedValue();
+      } else if (value && !Array.isArray(value) && typeof value === "object") {
+        updatedStyle[key] = this._walkStyleAndGetAnimatedValues(value);
+      }
+    }
+    return updatedStyle;
+  }
+  __getAnimatedValue() {
+    return this._walkStyleAndGetAnimatedValues(this._style);
+  }
+  __attach() {
+    for (const key in this._style) {
+      const value = this._style[key];
+      if (value instanceof import_AnimatedNode.AnimatedNode) {
+        value.__addChild(this);
+      }
+    }
+  }
+  __detach() {
+    for (const key in this._style) {
+      const value = this._style[key];
+      if (value instanceof import_AnimatedNode.AnimatedNode) {
+        value.__removeChild(this);
+      }
+    }
+    super.__detach();
+  }
+  __makeNative() {
+    for (const key in this._style) {
+      const value = this._style[key];
+      if (value instanceof import_AnimatedNode.AnimatedNode) {
+        value.__makeNative();
+      }
+    }
+    super.__makeNative();
+  }
+  __getNativeConfig() {
+    const styleConfig = {};
+    for (const styleKey in this._style) {
+      if (this._style[styleKey] instanceof import_AnimatedNode.AnimatedNode) {
+        const style = this._style[styleKey];
+        style.__makeNative();
+        styleConfig[styleKey] = style.__getNativeTag();
+      }
+    }
+    import_NativeAnimatedHelper.NativeAnimatedHelper.validateStyles(styleConfig);
+    return {
+      type: "style",
+      style: styleConfig
+    };
+  }
+}
+var AnimatedStyle_default = AnimatedStyle;

package/dist/cjs/vendor/react-native/Animated/nodes/AnimatedSubtraction.cjs

@@ -0,0 +1,69 @@
+"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 AnimatedSubtraction_exports = {};
+__export(AnimatedSubtraction_exports, {
+  AnimatedSubtraction: () => AnimatedSubtraction,
+  default: () => AnimatedSubtraction_default
+});
+module.exports = __toCommonJS(AnimatedSubtraction_exports);
+var import_AnimatedInterpolation = require("./AnimatedInterpolation.cjs");
+var import_AnimatedValue = require("./AnimatedValue.cjs");
+var import_AnimatedWithChildren = require("./AnimatedWithChildren.cjs");
+class AnimatedSubtraction extends import_AnimatedWithChildren.AnimatedWithChildren {
+  _a;
+  _b;
+  constructor(a, b) {
+    super();
+    this._a = typeof a === "number" ? new import_AnimatedValue.AnimatedValue(a) : a;
+    this._b = typeof b === "number" ? new import_AnimatedValue.AnimatedValue(b) : b;
+  }
+  __makeNative(platformConfig) {
+    this._a.__makeNative(platformConfig);
+    this._b.__makeNative(platformConfig);
+    super.__makeNative(platformConfig);
+  }
+  __getValue() {
+    return this._a.__getValue() - this._b.__getValue();
+  }
+  interpolate(config) {
+    return new import_AnimatedInterpolation.AnimatedInterpolation(this, config);
+  }
+  __attach() {
+    this._a.__addChild(this);
+    this._b.__addChild(this);
+  }
+  __detach() {
+    this._a.__removeChild(this);
+    this._b.__removeChild(this);
+    super.__detach();
+  }
+  __getNativeConfig() {
+    return {
+      type: "subtraction",
+      input: [this._a.__getNativeTag(), this._b.__getNativeTag()]
+    };
+  }
+}
+var AnimatedSubtraction_default = AnimatedSubtraction;

package/dist/cjs/vendor/react-native/Animated/nodes/AnimatedTracking.cjs

@@ -0,0 +1,90 @@
+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 AnimatedTracking_exports = {};
+__export(AnimatedTracking_exports, {
+  AnimatedTracking: () => AnimatedTracking,
+  default: () => AnimatedTracking_default
+});
+module.exports = __toCommonJS(AnimatedTracking_exports);
+var import_AnimatedValue = require("./AnimatedValue.cjs");
+var import_AnimatedNode = require("./AnimatedNode.cjs");
+var import_NativeAnimatedHelper = require("../NativeAnimatedHelper.cjs");
+class AnimatedTracking extends import_AnimatedNode.AnimatedNode {
+  _value;
+  _parent;
+  _callback;
+  _animationConfig;
+  _animationClass;
+  _useNativeDriver;
+  constructor(value, parent, animationClass, animationConfig, callback) {
+    super();
+    this._value = value;
+    this._parent = parent;
+    this._animationClass = animationClass;
+    this._animationConfig = animationConfig;
+    this._useNativeDriver = (0, import_NativeAnimatedHelper.shouldUseNativeDriver)(animationConfig);
+    this._callback = callback;
+    this.__attach();
+  }
+  __makeNative() {
+    this.__isNative = true;
+    this._parent.__makeNative();
+    super.__makeNative();
+    this._value.__makeNative();
+  }
+  __getValue() {
+    return this._parent.__getValue();
+  }
+  __attach() {
+    this._parent.__addChild(this);
+    if (this._useNativeDriver) {
+      this.__makeNative();
+    }
+  }
+  __detach() {
+    this._parent.__removeChild(this);
+    super.__detach();
+  }
+  update() {
+    this._value.animate(new this._animationClass({
+      ...this._animationConfig,
+      toValue: this._animationConfig.toValue.__getValue()
+    }), this._callback);
+  }
+  __getNativeConfig() {
+    const animation = new this._animationClass({
+      ...this._animationConfig,
+      // remove toValue from the config as it's a ref to Animated.Value
+      toValue: void 0
+    });
+    const animationConfig = animation.__getNativeAnimationConfig();
+    return {
+      type: "tracking",
+      animationId: (0, import_NativeAnimatedHelper.generateNewAnimationId)(),
+      animationConfig,
+      toValue: this._parent.__getNativeTag(),
+      value: this._value.__getNativeTag()
+    };
+  }
+}
+var AnimatedTracking_default = AnimatedTracking;

package/dist/cjs/vendor/react-native/Animated/nodes/AnimatedTransform.cjs

@@ -0,0 +1,127 @@
+"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 AnimatedTransform_exports = {};
+__export(AnimatedTransform_exports, {
+  AnimatedTransform: () => AnimatedTransform,
+  default: () => AnimatedTransform_default
+});
+module.exports = __toCommonJS(AnimatedTransform_exports);
+var import_AnimatedNode = require("./AnimatedNode.cjs");
+var import_AnimatedWithChildren = require("./AnimatedWithChildren.cjs");
+var import_NativeAnimatedHelper = require("../NativeAnimatedHelper.cjs");
+class AnimatedTransform extends import_AnimatedWithChildren.AnimatedWithChildren {
+  _transforms;
+  constructor(transforms) {
+    super();
+    this._transforms = transforms;
+  }
+  __makeNative() {
+    this._transforms.forEach(transform => {
+      for (const key in transform) {
+        const value = transform[key];
+        if (value instanceof import_AnimatedNode.AnimatedNode) {
+          value.__makeNative();
+        }
+      }
+    });
+    super.__makeNative();
+  }
+  __getValue() {
+    return this._transforms.map(transform => {
+      const result = {};
+      for (const key in transform) {
+        const value = transform[key];
+        if (value instanceof import_AnimatedNode.AnimatedNode) {
+          result[key] = value.__getValue();
+        } else {
+          result[key] = value;
+        }
+      }
+      return result;
+    });
+  }
+  __getAnimatedValue() {
+    return this._transforms.map(transform => {
+      const result = {};
+      for (const key in transform) {
+        const value = transform[key];
+        if (value instanceof import_AnimatedNode.AnimatedNode) {
+          result[key] = value.__getAnimatedValue();
+        } else {
+          result[key] = value;
+        }
+      }
+      return result;
+    });
+  }
+  __attach() {
+    this._transforms.forEach(transform => {
+      for (const key in transform) {
+        const value = transform[key];
+        if (value instanceof import_AnimatedNode.AnimatedNode) {
+          value.__addChild(this);
+        }
+      }
+    });
+  }
+  __detach() {
+    this._transforms.forEach(transform => {
+      for (const key in transform) {
+        const value = transform[key];
+        if (value instanceof import_AnimatedNode.AnimatedNode) {
+          value.__removeChild(this);
+        }
+      }
+    });
+    super.__detach();
+  }
+  __getNativeConfig() {
+    const transConfigs = [];
+    this._transforms.forEach(transform => {
+      for (const key in transform) {
+        const value = transform[key];
+        if (value instanceof import_AnimatedNode.AnimatedNode) {
+          transConfigs.push({
+            type: "animated",
+            property: key,
+            nodeTag: value.__getNativeTag()
+          });
+        } else {
+          transConfigs.push({
+            type: "static",
+            property: key,
+            value: import_NativeAnimatedHelper.NativeAnimatedHelper.transformDataType(value)
+          });
+        }
+      }
+    });
+    import_NativeAnimatedHelper.NativeAnimatedHelper.validateTransform(transConfigs);
+    return {
+      type: "transform",
+      transforms: transConfigs
+    };
+  }
+}
+var AnimatedTransform_default = AnimatedTransform;