@react-native-ohos/react-native-bindingx 1.0.4-rc.1

package/harmony/bindingx/src/main/ets/TimingFunctions.ts

@@ -0,0 +1,281 @@
+/**
+ * MIT License
+ *
+ * Copyright (C) 2024 Huawei Device Co., Ltd.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+export class TimingFunctions {
+  public static linear(t: number, b: number, c: number, d: number): number {
+    t = Math.min(t, d);
+    return c * (t / d) + b;
+  }
+
+
+  public static easeOutElastic(t: number, b: number, c: number, d: number): number {
+    t = Math.min(t, d);
+    let s = 0;
+    let p = 0;
+    let a = c;
+    p = d * .3;
+    if (a < Math.abs(c)) {
+      a = c;
+      s = p / 4;
+    } else {
+      s = p / (2 * Math.PI) * Math.asin(c / a);
+    }
+    return a * Math.pow(2, -10 * t) * Math.sin((t * d - s) * (2 * Math.PI) / p) + c + b;
+  }
+
+  public static easeInQuad(t: number, b: number, c: number, d: number): number {
+    t = Math.min(t, d);
+    return c * (t /= d) * t + b;
+  }
+
+  public static easeOutQuad(t: number, b: number, c: number, d: number): number {
+    t = Math.min(t, d);
+    return -c * (t /= d) * (t - 2) + b;
+  }
+
+  public static easeInOutQuad(t: number, b: number, c: number, d: number): number {
+    t = Math.min(t, d);
+    if ((t /= d / 2) < 1) {
+      return c / 2 * t * t + b;
+    }
+    return -c / 2 * ((--t) * (t - 2) - 1) + b;
+  }
+
+  public static easeInCubic(t: number, b: number, c: number, d: number): number {
+    t = Math.min(t, d);
+    return c * (t /= d) * t * t + b;
+  }
+
+  public static easeOutCubic(t: number, b: number, c: number, d: number): number {
+    t = Math.min(t, d);
+    return c * ((t = t / d - 1) * t * t + 1) + b;
+  }
+
+  public static easeInOutCubic(t: number, b: number, c: number, d: number): number {
+    t = Math.min(t, d);
+    if ((t /= d / 2) < 1) {
+      return c / 2 * t * t * t + b;
+    }
+    return c / 2 * ((t -= 2) * t * t + 2) + b;
+  }
+
+  public static easeInQuart(t: number, b: number, c: number, d: number): number {
+    t = Math.min(t, d);
+    return c * (t /= d) * t * t * t + b;
+  }
+
+  public static easeOutQuart(t: number, b: number, c: number, d: number): number {
+    t = Math.min(t, d);
+    return -c * ((t = t / d - 1) * t * t * t - 1) + b;
+  }
+
+  public static easeInOutQuart(t: number, b: number, c: number, d: number): number {
+    t = Math.min(t, d);
+    if ((t /= d / 2) < 1) {
+      return c / 2 * t * t * t * t + b;
+    }
+    return -c / 2 * ((t -= 2) * t * t * t - 2) + b;
+  }
+
+  public static easeInQuint(t: number, b: number, c: number, d: number): number {
+    t = Math.min(t, d);
+    return c * (t /= d) * t * t * t * t + b;
+  }
+
+  public static easeOutQuint(t: number, b: number, c: number, d: number): number {
+    t = Math.min(t, d);
+    return c * ((t = t / d - 1) * t * t * t * t + 1) + b;
+  }
+
+  public static easeInOutQuint(t: number, b: number, c: number, d: number): number {
+    t = Math.min(t, d);
+    if ((t /= d / 2) < 1) {
+      return c / 2 * t * t * t * t * t + b;
+    }
+    return c / 2 * ((t -= 2) * t * t * t * t + 2) + b;
+  }
+
+  public static easeInSine(t: number, b: number, c: number, d: number): number {
+    t = Math.min(t, d);
+    return -c * Math.cos(t / d * (Math.PI / 2)) + c + b;
+  }
+
+
+  public static easeOutSine(t: number, b: number, c: number, d: number): number {
+    t = Math.min(t, d);
+    if ((t /= d / 2) < 1) {
+      return c / 2 * t * t * t * t * t + b;
+    }
+    return c / 2 * ((t -= 2) * t * t * t * t + 2) + b;
+  }
+
+  public static easeInExpo(t: number, b: number, c: number, d: number): number {
+    t = Math.min(t, d);
+    return (t == 0) ? b : c * Math.pow(2, 10 * (t / d - 1)) + b;
+  }
+
+  public static easeOutExpo(t: number, b: number, c: number, d: number): number {
+    t = Math.min(t, d);
+    return (t == d) ? b + c : c * (-Math.pow(2, -10 * t / d) + 1) + b;
+  }
+
+  public static easeInOutExpo(t: number, b: number, c: number, d: number): number {
+    t = Math.min(t, d);
+    if (t == 0) {
+      return b;
+    }
+    if (t == d) {
+      return b + c;
+    }
+    if ((t /= d / 2) < 1) {
+      return c / 2 * Math.pow(2, 10 * (t - 1)) + b;
+    }
+    return c / 2 * (-Math.pow(2, -10 * --t) + 2) + b;
+  }
+
+  public static easeInCirc(t: number, b: number, c: number, d: number): number {
+    t = Math.min(t, d);
+    return -c * (Math.sqrt(1 - (t /= d) * t) - 1) + b;
+  }
+
+  public static easeOutCirc(t: number, b: number, c: number, d: number): number {
+    t = Math.min(t, d);
+    return c * Math.sqrt(1 - (t = t / d - 1) * t) + b;
+  }
+
+  public static easeInOutCirc(t: number, b: number, c: number, d: number): number {
+    t = Math.min(t, d);
+    if ((t /= d / 2) < 1) {
+      return -c / 2 * (Math.sqrt(1 - t * t) - 1) + b;
+    }
+    return c / 2 * (Math.sqrt(1 - (t -= 2) * t) + 1) + b;
+  }
+
+  public static easeInElastic(t: number, b: number, c: number, d: number): number {
+    t = Math.min(t, d);
+    let s;
+    let p;
+    let a = c;
+    if (t == 0) {
+      return b;
+    }
+    if ((t /= d) == 1) {
+      return b + c;
+    }
+    p = d * .3;
+    if (a < Math.abs(c)) {
+      a = c;
+      s = p / 4;
+    } else {
+      s = p / (2 * Math.PI) * Math.asin(c / a);
+    }
+    return -(a * Math.pow(2, 10 * (t -= 1)) * Math.sin((t * d - s) * (2 * Math.PI) / p)) + b;
+  }
+
+  public static easeInOutElastic(t: number, b: number, c: number, d: number): number {
+    t = Math.min(t, d);
+
+    let s;
+    let p;
+    let a = c;
+    if (t == 0) {
+      return b;
+    }
+    if ((t /= d / 2) == 2) {
+      return b + c;
+    }
+    p = d * (.3 * 1.5);
+    if (a < Math.abs(c)) {
+      a = c;
+      s = p / 4;
+    } else {
+      s = p / (2 * Math.PI) * Math.asin(c / a);
+    }
+    if (t < 1) {
+      return -.5 * (a * Math.pow(2, 10 * (t -= 1)) * Math.sin((t * d - s) * (2 * Math.PI) / p)) + b;
+    }
+    return a * Math.pow(2, -10 * (t -= 1)) * Math.sin((t * d - s) * (2 * Math.PI) / p) * .5 + c + b;
+  }
+
+  public static easeInBack(t: number, b: number, c: number, d: number): number {
+    t = Math.min(t, d);
+    let s = 1.70158;
+    return c * (t /= d) * t * ((s + 1) * t - s) + b;
+  }
+
+  public static easeOutBack(t: number, b: number, c: number, d: number): number {
+    t = Math.min(t, d);
+    let s = 1.70158;
+    return c * ((t = t / d - 1) * t * ((s + 1) * t + s) + 1) + b;
+  }
+
+  public static easeInOutBack(t: number, b: number, c: number, d: number): number {
+    t = Math.min(t, d);
+    let s = 1.70158;
+    if ((t /= d / 2) < 1) {
+      return c / 2 * (t * t * (((s *= (1.525)) + 1) * t - s)) + b;
+    }
+    return c / 2 * ((t -= 2) * t * (((s *= (1.525)) + 1) * t + s) + 2) + b;
+  }
+
+  public static easeInBounce(t: number, b: number, c: number, d: number): number {
+    t = Math.min(t, d);
+    return TimingFunctions.easeInBounce1(t, b, c, d);
+  }
+
+  public static easeOutBounce(t: number, b: number, c: number, d: number): number {
+    t = Math.min(t, d);
+    return TimingFunctions.easeOutBounce1(t, b, c, d);
+  }
+
+
+  public static easeInBounce1(t: number, b: number, c: number, d: number): number {
+    return c - TimingFunctions.easeOutBounce1(d - t, 0, c, d) + b;
+  }
+
+  public static easeOutBounce1(t: number, b: number, c: number, d: number): number {
+    if ((t /= d) < (1 / 2.75)) {
+      return c * (7.5625 * t * t) + b;
+    } else if (t < (2 / 2.75)) {
+      return c * (7.5625 * (t -= (1.5 / 2.75)) * t + .75) + b;
+    } else if (t < (2.5 / 2.75)) {
+      return c * (7.5625 * (t -= (2.25 / 2.75)) * t + .9375) + b;
+    } else {
+      return c * (7.5625 * (t -= (2.625 / 2.75)) * t + .984375) + b;
+    }
+  }
+
+  public static easeInOutBounce(t: number, b: number, c: number, d: number): number {
+    t = Math.min(t, d);
+    if (t < d / 2) {
+      return TimingFunctions.easeInBounce1(t * 2, 0, c, d) * .5 + b;
+    }
+    return TimingFunctions.easeOutBounce1(t * 2 - d, 0, c, d) * .5 + c * .5 + b;
+  }
+
+  public static easeInOutSine(t: number, b: number, c: number, d: number): number {
+    t = Math.min(t, d);
+    return -c / 2 * (Math.cos(Math.PI * t / d) - 1) + b;
+  }
+}

package/harmony/bindingx/src/main/ets/TimingFunctionsType.ts

@@ -0,0 +1,58 @@
+/**
+ * MIT License
+ *
+ * Copyright (C) 2024 Huawei Device Co., Ltd.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+export enum TimingFunctionsType {
+  linear,
+  easeInQuad,
+  easeOutQuad,
+  easeInOutQuad,
+  easeInCubic,
+  easeOutCubic,
+  easeInOutCubic,
+  easeInQuart,
+  easeOutQuart,
+  easeInOutQuart,
+  easeInQuint,
+  easeOutQuint,
+  easeInOutQuint,
+  easeInSine,
+  easeOutSine,
+  easeInOutSine,
+  easeInExpo,
+  easeOutExpo,
+  easeInOutExpo,
+  easeInCirc,
+  easeOutCirc,
+  easeInOutCirc,
+  easeInElastic,
+  easeOutElastic,
+  easeInOutElastic,
+  easeInBack,
+  easeOutBack,
+  easeInOutBack,
+  easeInBounce,
+  easeOutBounce,
+  easeInOutBounce,
+  cubicBezier
+}

package/harmony/bindingx/src/main/ets/TimingFunctionsTypeHandler.ts

@@ -0,0 +1,128 @@
+/**
+ * MIT License
+ *
+ * Copyright (C) 2024 Huawei Device Co., Ltd.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+import { TimingFunctionsType } from './TimingFunctionsType';
+
+export class TimingFunctionsTypeHandler {
+  public static handlerStringType(str: string): TimingFunctionsType {
+    let type = str.substring(0, str.indexOf("("))
+    if (type == "liner") {
+      return TimingFunctionsType.linear
+    }
+    else if (type == "easeInQuad") {
+      return TimingFunctionsType.easeInQuad
+    }
+    else if (type == "easeOutQuad") {
+      return TimingFunctionsType.easeOutQuad
+    }
+    else if (type == "easeInOutQuad") {
+      return TimingFunctionsType.easeInOutQuad
+    }
+    else if (type == "easeInCubic") {
+      return TimingFunctionsType.easeInCubic
+    }
+    else if (type == "easeOutCubic") {
+      return TimingFunctionsType.easeOutCubic
+    }
+    else if (type == "easeOutElastic") {
+      return TimingFunctionsType.easeOutElastic
+    }
+    else if (type == "easeInOutCubic") {
+      return TimingFunctionsType.easeInOutCubic
+    }
+    else if (type == "easeInQuart") {
+      return TimingFunctionsType.easeInQuart
+    }
+    else if (type == "easeOutQuart") {
+      return TimingFunctionsType.easeOutQuart
+    }
+    else if (type == "easeInQuint") {
+      return TimingFunctionsType.easeInQuint
+    }
+    else if (type == "easeOutQuint") {
+      return TimingFunctionsType.easeOutQuint
+    }
+    else if (type == "easeInOutQuint") {
+      return TimingFunctionsType.easeInOutQuint
+    }
+    else if (type == "easeInSine") {
+      return TimingFunctionsType.easeInSine
+    }
+    else if (type == "easeOutSine") {
+      return TimingFunctionsType.easeOutSine
+    }
+    else if (type == "easeInOutSine") {
+      return TimingFunctionsType.easeInOutSine
+    }
+    else if (type == "easeInExpo") {
+      return TimingFunctionsType.easeInExpo
+    }
+    else if (type == "easeOutExpo") {
+      return TimingFunctionsType.easeOutExpo
+    }
+    else if (type == "easeInOutExpo") {
+      return TimingFunctionsType.easeInOutExpo
+    }
+    else if (type == "easeInCirc") {
+      return TimingFunctionsType.easeInCirc
+    }
+    else if (type == "easeOutCirc") {
+      return TimingFunctionsType.easeOutCirc
+    }
+    else if (type == "easeInOutCirc") {
+      return TimingFunctionsType.easeInOutCirc
+    }
+    else if (type == "easeInElastic") {
+      return TimingFunctionsType.easeInElastic
+    }
+    else if (type == "easeOutElastic") {
+      return TimingFunctionsType.easeOutElastic
+    }
+    else if (type == "easeInOutElastic") {
+      return TimingFunctionsType.easeInOutElastic
+    }
+    else if (type == "easeInBack") {
+      return TimingFunctionsType.easeInBack
+    }
+    else if (type == "easeOutBack") {
+      return TimingFunctionsType.easeOutBack
+    }
+    else if (type == "easeInOutBack") {
+      return TimingFunctionsType.easeInOutBack
+    }
+    else if (type == "easeInBounce") {
+      return TimingFunctionsType.easeInBounce
+    }
+    else if (type == "easeOutBounce") {
+      return TimingFunctionsType.easeOutBounce
+    }
+    else if (type == "easeInOutBounce") {
+      return TimingFunctionsType.easeInOutBounce
+    }
+    else if (type == "cubicBezier") {
+      return TimingFunctionsType.cubicBezier
+    }
+    return TimingFunctionsType.linear
+  }
+}

package/harmony/bindingx/src/main/module.json5

@@ -0,0 +1,7 @@
+{
+  module: {
+    name: 'bindingx',
+    type: 'har',
+    deviceTypes: ['default'],
+  },
+}

package/harmony/bindingx/src/main/resources/base/element/color.json

@@ -0,0 +1,8 @@
+{
+  "color": [
+    {
+      "name": "start_window_background",
+      "value": "#FFFFFF"
+    }
+  ]
+}

package/harmony/bindingx/src/main/resources/base/element/string.json

@@ -0,0 +1,16 @@
+{
+  "string": [
+    {
+      "name": "module_desc",
+      "value": "module description"
+    },
+    {
+      "name": "WebviewAbility_desc",
+      "value": "description"
+    },
+    {
+      "name": "WebviewAbility_label",
+      "value": "label"
+    }
+  ]
+}

package/harmony/bindingx/src/main/resources/base/profile/main_pages.json

@@ -0,0 +1,5 @@
+{
+  "src": [
+    "pages/Index"
+  ]
+}

package/harmony/bindingx/src/main/resources/en_US/element/string.json

@@ -0,0 +1,16 @@
+{
+  "string": [
+    {
+      "name": "module_desc",
+      "value": "module description"
+    },
+    {
+      "name": "WebviewAbility_desc",
+      "value": "description"
+    },
+    {
+      "name": "WebviewAbility_label",
+      "value": "label"
+    }
+  ]
+}

package/harmony/bindingx/src/main/resources/zh_CN/element/string.json

@@ -0,0 +1,16 @@
+{
+  "string": [
+    {
+      "name": "module_desc",
+      "value": "模块描述"
+    },
+    {
+      "name": "WebviewAbility_desc",
+      "value": "description"
+    },
+    {
+      "name": "WebviewAbility_label",
+      "value": "label"
+    }
+  ]
+}

package/harmony/bindingx/ts.ts

@@ -0,0 +1,26 @@
+/**
+ * MIT License
+ *
+ * Copyright (C) 2024 Huawei Device Co., Ltd.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+export * from "./src/main/ets/ReactBindingXPackage"
+export * from "./src/main/ets/ReactBindingXModule"

package/lib/index.js

@@ -0,0 +1,3 @@
+import bindingx from './src/bindingx';
+
+module.exports = bindingx;

package/lib/specs/NativeReactBindingXModule.ts

@@ -0,0 +1,12 @@
+
+import { TurboModuleRegistry, TurboModule } from 'react-native';
+
+export interface Spec extends TurboModule {
+    bind: (options: Object) => string;
+    unbind: (options: Object) => void;
+    unbindAll: () => void;
+    prepare: (options: Object) => void;
+    getComputedStyle: (options: Object) => Promise<string>;
+  }
+  
+  export default TurboModuleRegistry.getEnforcing<Spec>('ReactBindingXModule');