@applicaster/zapp-react-native-utils 13.0.0-alpha.2569962250 → 13.0.0-alpha.2685746452

package/time/BackgroundTimer.ts

@@ -0,0 +1,55 @@
+import { DeviceEventEmitter, NativeModules } from "react-native";
+import { platformSelect } from "../reactUtils";
+
+const { BackgroundTimer: RNBackgroundTimer } = NativeModules;
+
+class BackgroundTimer {
+  private uniqueId: number;
+  private readonly callbacks: Record<number, () => void>;
+
+  constructor() {
+    this.uniqueId = 0;
+    this.callbacks = {};
+
+    const EventEmitter = platformSelect({
+      android: DeviceEventEmitter,
+      ios: undefined,
+      default: undefined,
+    });
+
+    EventEmitter?.addListener("BackgroundTimer.timer.fired", (id: number) => {
+      if (this.callbacks[id]) {
+        const callback = this.callbacks[id];
+        delete this.callbacks[id];
+        callback();
+      }
+    });
+  }
+
+  setTimeout(callback, timeout): number | NodeJS.Timeout {
+    if (!RNBackgroundTimer) {
+      return global.setTimeout(callback, timeout);
+    }
+
+    this.uniqueId += 1;
+    const timeoutId = this.uniqueId;
+
+    this.callbacks[timeoutId] = callback;
+    RNBackgroundTimer.setTimeout(timeoutId, timeout);
+
+    return timeoutId;
+  }
+
+  clearTimeout(timeoutId: number | NodeJS.Timeout): void {
+    if (!RNBackgroundTimer) {
+      return global.clearTimeout(timeoutId as NodeJS.Timeout);
+    }
+
+    if (this.callbacks[timeoutId as number]) {
+      delete this.callbacks[timeoutId as number];
+      RNBackgroundTimer.clearTimeout(timeoutId);
+    }
+  }
+}
+
+export default new BackgroundTimer();

package/time/Timer.ts

@@ -1,19 +1,19 @@
+import BackgroundTimer from "./BackgroundTimer";
+
 export class Timer {
   private startTime: number;
-  private remaining: number;
-  private timeoutId: NodeJS.Timeout | null;
+  private timeoutId: number | NodeJS.Timeout | null;
 
   constructor(
     private callback: () => void,
-    private duration: number
+    private remaining: number = null
   ) {
-    this.remaining = this.duration;
     this.timeoutId = null;
   }
 
   start(): void {
     this.startTime = Date.now();
-    this.timeoutId = setTimeout(this.callback, this.remaining);
+    this.timeoutId = BackgroundTimer.setTimeout(this.callback, this.remaining);
 
     this.remaining = 0;
   }
@@ -29,6 +29,6 @@ export class Timer {
   }
 
   clear(): void {
-    clearTimeout(this.timeoutId);
+    BackgroundTimer.clearTimeout(this.timeoutId);
   }
 }

package/utils/README.md

@@ -0,0 +1,34 @@
+### ramda replacement utils
+
+See contribution guide below
+
+## Reference
+
+
+### _.flatten
+R.times => flatten.ts
+
+### _.times
+R.times => times.ts
+
+### _.drop
+R.drop(N,array) => array.slice(N)
+
+### _.clone
+R.clone => clone.ts
+
+### _.splitEvery
+R.splitEvery => splitEvery.ts
+
+### _.length
+R.length(data) => data?.length ?? 0
+
+## Contribution
+
+To add new helper function 
+
+1. Search for replacement ( you can reuse lodash, preferable pure JS solution), arguments should match with Ramda definition 
+2. Add new file, update exports in index file
+3. If replacement is simple enough that doesn't need a function - add snippet to this README
+4. Make sure README is updated and contains reference for newly added function
+5. Write unit test to test input/output. You can use AI's help.

package/utils/clone.ts

@@ -0,0 +1,56 @@
+/**
+ * Creates a deep copy of the value which may contain (nested) `Array`s and `Object`s,
+ * `Number`s, `String`s, `Boolean`s and `Date`s. `Function`s are assigned by reference
+ * rather than copied. Dispatches to a `clone` method if present.
+ *
+ * @param {*} value - The value to clone
+ * @return {*} A deep copy of the provided value
+ */
+export const clone = (value) => {
+  // Handle null or undefined
+  if (value == null) {
+    return value;
+  }
+
+  // Check if value has a custom clone method
+  if (typeof value.clone === "function") {
+    return value.clone();
+  }
+
+  // Handle primitive types (they're immutable so no need to clone)
+  if (typeof value !== "object") {
+    return value;
+  }
+
+  // Handle Date objects
+  if (value instanceof Date) {
+    return new Date(value.getTime());
+  }
+
+  // Handle RegExp objects
+  if (value instanceof RegExp) {
+    return new RegExp(value.source, value.flags);
+  }
+
+  // Handle Array objects
+  if (Array.isArray(value)) {
+    return value.map((item) => clone(item));
+  }
+
+  // Handle Object literals
+  if (Object.prototype.toString.call(value) === "[object Object]") {
+    const result = {};
+    const keys = Object.keys(value);
+
+    for (let i = 0; i < keys.length; i++) {
+      const key = keys[i];
+      result[key] = clone(value[key]);
+    }
+
+    return result;
+  }
+
+  // For other types like Maps, Sets, etc., we would need additional handling
+  // For simplicity, we'll return the original value for unsupported types
+  return value;
+};

package/utils/flatten.ts

@@ -0,0 +1,3 @@
+export const flatten = <T>(array: (T & T[])[]) => {
+  return array.flat(Infinity);
+};

package/utils/index.ts

@@ -0,0 +1,7 @@
+export { times } from "./times";
+
+export { flatten } from "./flatten";
+
+export { clone } from "./clone";
+
+export { splitEvery } from "./splitEvery";

package/utils/splitEvery.ts

@@ -0,0 +1,27 @@
+export function splitEvery(size, collection) {
+  if (size <= 0) {
+    throw new Error("First argument to splitEvery must be a positive integer");
+  }
+
+  const result = [];
+
+  // Handle string input
+  if (typeof collection === "string") {
+    for (let i = 0; i < collection.length; i += size) {
+      result.push(collection.slice(i, i + size));
+    }
+
+    return result;
+  }
+
+  // Handle array input
+  if (Array.isArray(collection)) {
+    for (let i = 0; i < collection.length; i += size) {
+      result.push(collection.slice(i, i + size));
+    }
+
+    return result;
+  }
+
+  return result;
+}

package/utils/times.ts

@@ -0,0 +1,2 @@
+export const times = (fn, n) =>
+  Array.from({ length: n }, (_, index) => fn(index));

package/reactUtils/createContext/__tests__/index-no-react.test.js

@@ -1,27 +0,0 @@
-jest.mock("create-react-context", () =>
-  jest.fn(() => ({
-    Consumer: jest.fn(),
-    Provider: jest.fn(),
-  }))
-);
-
-jest.mock("react", () => ({
-  ...jest.requireActual("react"),
-  createContext: undefined,
-}));
-
-const { createContext } = require("../index");
-const createReactContext = require("create-react-context");
-
-describe("when react context api is not defined", () => {
-  it("uses the polyfill", () => {
-    createContext({ foo: "bar" });
-
-    expect(createReactContext).toHaveBeenCalledWith(
-      expect.objectContaining({
-        foo: "bar",
-        setFoo: expect.any(Function),
-      })
-    );
-  });
-});