@applicaster/zapp-react-native-utils 16.0.0-rc.7 → 16.0.0-rc.71

package/modalState/useBottomSheetContent.ts

@@ -0,0 +1,102 @@
+import React, { useEffect, useState } from "react";
+import { toBooleanWithDefaultFalse } from "@applicaster/zapp-react-native-utils/booleanUtils";
+
+import {
+  isPresentSubMenuAction,
+  MenuItem,
+  modalOrchestrator,
+} from "./ModalOrchestrator";
+
+import { ContentViewModel } from "./ContentViewModel";
+import type { DynamicCollectionOptions, SelectionBehavior } from "./types";
+import type { EditableCollection } from "./EditableCollection";
+
+type Props = {
+  viewModel?: ContentViewModel | null;
+  onPress: (item: MenuItem) => void | Promise<void>;
+};
+
+type Return = {
+  items: MenuItem[];
+  isLoading: boolean;
+  error?: Error | string;
+  showCentralLoading: boolean;
+  canGoBack: boolean;
+  handleItemPress: (item: MenuItem) => Promise<void>;
+  goBackOrClose: () => void;
+  close: () => void;
+  role?: string;
+  behavior?: SelectionBehavior;
+  dynamicCollection?: DynamicCollectionOptions;
+  editableCollection: EditableCollection | null;
+  themePluginId?: string;
+};
+
+export const useBottomSheetContent = (props: Props): Return => {
+  const { onPress, viewModel } = props;
+
+  const [state, setState] = useState(viewModel?.getState());
+
+  const [editableItems, setEditableItems] = useState<MenuItem[]>(
+    () => viewModel?.getState().items || []
+  );
+
+  // Subscribe to the viewModel state changes
+  useEffect(() => {
+    return viewModel?.subscribe((nextState) => {
+      setState(nextState);
+    });
+  }, [viewModel]);
+
+  // Subscribe to editable collection items
+  useEffect(() => {
+    if (viewModel?.editableCollection) {
+      const subscription =
+        viewModel.editableCollection.items$.subscribe(setEditableItems);
+
+      return () => subscription.unsubscribe();
+    }
+  }, [viewModel?.editableCollection]);
+
+  /**
+   * Handles an item press:
+   * - Delegates to the parent onPress (which runs the action and awaits it).
+   * - If the item was a leaf action (not a submenu), triggers viewModel.refetch()
+   *   so that checkmarks (isSelected) reflect the updated server state.
+   */
+  const handleItemPress = async (item: MenuItem) => {
+    const isSubMenu = item.action && isPresentSubMenuAction(item.action);
+
+    await onPress(item);
+
+    if (!isSubMenu) {
+      await viewModel?.refetch();
+    }
+  };
+
+  const goBackOrClose = React.useCallback(() => {
+    if (modalOrchestrator.canGoBack) {
+      modalOrchestrator.back();
+    } else {
+      modalOrchestrator.close();
+    }
+  }, [modalOrchestrator.canGoBack]);
+
+  return {
+    items: viewModel?.editableCollection ? editableItems : state?.items,
+    isLoading: toBooleanWithDefaultFalse(state?.isLoading),
+    error: state?.error,
+    showCentralLoading: toBooleanWithDefaultFalse(
+      state?.isLoading && state?.items.length === 0
+    ),
+    canGoBack: modalOrchestrator.canGoBack,
+    handleItemPress,
+    goBackOrClose,
+    close: () => modalOrchestrator.close(),
+    role: state?.role,
+    behavior: state?.behavior,
+    dynamicCollection: state?.dynamicCollection,
+    editableCollection: viewModel?.editableCollection || null,
+    themePluginId: state?.themePluginId,
+  };
+};

package/numberUtils/__tests__/isMinusZero.test.ts

@@ -0,0 +1,20 @@
+import { isMinusZero } from "..";
+
+describe("isMinusZero", () => {
+  it("return true for minus zero", () => {
+    expect(isMinusZero(-0)).toBe(true);
+  });
+
+  it("return false for positive zero", () => {
+    expect(isMinusZero(0)).toBe(false);
+  });
+
+  it("return false for non-zero numbers", () => {
+    const inputs = [-1, 1, 100, 0.1, -0.1, Infinity, -Infinity];
+    expect.assertions(inputs.length);
+
+    inputs.forEach((input) => {
+      expect(isMinusZero(input)).toBe(false);
+    });
+  });
+});

package/numberUtils/__tests__/isZero.test.ts

@@ -0,0 +1,27 @@
+import { isZero } from "..";
+
+describe("isZero", () => {
+  it("return true for zero and minus zero", () => {
+    expect(isZero(0)).toBe(true);
+    expect(isZero(-0)).toBe(true);
+  });
+
+  it("return false for non-zero numbers", () => {
+    const inputs = [-1, 1, 100, 0.1, -0.1, Infinity, -Infinity, NaN];
+    expect.assertions(inputs.length);
+
+    inputs.forEach((input) => {
+      expect(isZero(input)).toBe(false);
+    });
+  });
+
+  it("return false for non-number values", () => {
+    const inputs = ["0", "-0", null, undefined, "", {}, [], false, true];
+
+    expect.assertions(inputs.length);
+
+    inputs.forEach((input) => {
+      expect(isZero(input)).toBe(false);
+    });
+  });
+});

package/numberUtils/__tests__/requireNumber.test.ts

@@ -0,0 +1,50 @@
+import { requireNumber } from "..";
+
+describe("requireNumber", () => {
+  it("return number if object key holds a number", () => {
+    const inputs = [-1, 1, 100, 0.2];
+    expect.assertions(inputs.length);
+
+    inputs.forEach((input) => {
+      const output = requireNumber({ value: input }, "value");
+      expect(output).toBe(input);
+    });
+  });
+
+  it("return number if object key holds a string as number", () => {
+    const inputs = ["-1", "1", "100", "0.2"];
+    expect.assertions(inputs.length);
+
+    inputs.forEach((input) => {
+      const output = requireNumber({ value: input }, "value");
+      expect(output).toBe(Number(input));
+    });
+  });
+
+  it("return null if object key holds zero", () => {
+    expect(requireNumber({ value: 0 }, "value")).toBeNull();
+    expect(requireNumber({ value: "0" }, "value")).toBeNull();
+  });
+
+  it("return null if object key is missing or not a number", () => {
+    const cases = [
+      [{}, "value"],
+      [{ value: null }, "value"],
+      [{ value: undefined }, "value"],
+      [{ value: NaN }, "value"],
+      [{ value: "" }, "value"],
+      [{ value: "vfdvf" }, "value"],
+      [{ value: {} }, "value"],
+      [{ value: [] }, "value"],
+      [null, "value"],
+      [undefined, "value"],
+    ] as const;
+
+    expect.assertions(cases.length);
+
+    cases.forEach(([obj, key]) => {
+      const output = requireNumber(obj, key);
+      expect(output).toBeNull();
+    });
+  });
+});

package/numberUtils/__tests__/toNumber.test.ts

@@ -21,6 +21,33 @@ describe("toNumber", () => {
     });
   });
 
+  it("return number if input is boxed string as number", () => {
+    const inputs = [
+      new String("-1"),
+      new String("0"),
+      new String("1"),
+      Object("100"),
+      Object("0.2"),
+    ];
+
+    expect.assertions(inputs.length);
+
+    inputs.forEach((input) => {
+      const output = toNumber(input);
+      expect(output).toBe(Number(input));
+    });
+  });
+
+  it("return undefined if input is invalid boxed string", () => {
+    const inputs = [new String("vfdvf"), new String("5n"), Object("")];
+    expect.assertions(inputs.length);
+
+    inputs.forEach((input) => {
+      const output = toNumber(input);
+      expect(output).toBeUndefined();
+    });
+  });
+
   it("return undefined if input is not a number", () => {
     const inputs = [
       "vfdvf",

package/numberUtils/__tests__/toNumberWithDefault.test.ts

@@ -0,0 +1,64 @@
+import { toNumberWithDefault } from "..";
+
+describe("toNumberWithDefault", () => {
+  const DEFAULT = 5;
+
+  it("return number if input is number", () => {
+    const inputs = [-1, 0, 1, 100, 0.2];
+    expect.assertions(inputs.length);
+
+    inputs.forEach((input) => {
+      const output = toNumberWithDefault(DEFAULT, input);
+      expect(output).toBe(input);
+    });
+  });
+
+  it("return number if input is string as number", () => {
+    const inputs = ["-1", "0", "1", "100", "0.2"];
+    expect.assertions(inputs.length);
+
+    inputs.forEach((input) => {
+      const output = toNumberWithDefault(DEFAULT, input);
+      expect(output).toBe(Number(input));
+    });
+  });
+
+  it("return default if input is not a number", () => {
+    const inputs = [
+      "vfdvf",
+      "5n",
+      "-5n",
+      null,
+      undefined,
+      NaN,
+      "",
+      {},
+      { test: 1 },
+      [],
+      [1],
+    ];
+
+    expect.assertions(inputs.length);
+
+    inputs.forEach((input) => {
+      const output = toNumberWithDefault(DEFAULT, input);
+      expect(output).toBe(DEFAULT);
+    });
+  });
+
+  describe("BigInt support", () => {
+    const isBigIntSupported = typeof BigInt !== "undefined";
+
+    if (isBigIntSupported) {
+      it("converts BigInt to number when BigInt is supported", () => {
+        expect(toNumberWithDefault(DEFAULT, BigInt(5))).toBe(5);
+        expect(toNumberWithDefault(DEFAULT, BigInt(0))).toBe(0);
+        expect(toNumberWithDefault(DEFAULT, BigInt(-10))).toBe(-10);
+      });
+    } else {
+      it("skips BigInt tests when BigInt is not supported", () => {
+        expect(typeof BigInt).toBe("undefined");
+      });
+    }
+  });
+});

package/numberUtils/__tests__/toNumberWithDefaultZero.test.ts

@@ -0,0 +1,48 @@
+import { toNumberWithDefaultZero } from "..";
+
+const DEFAULT = 0;
+
+describe("toNumberWithDefaultZero", () => {
+  it("return number if input is number", () => {
+    const inputs = [-1, 0, 1, 100, 0.2];
+    expect.assertions(inputs.length);
+
+    inputs.forEach((input) => {
+      const output = toNumberWithDefaultZero(input);
+      expect(output).toBe(input);
+    });
+  });
+
+  it("return number if input is string as number", () => {
+    const inputs = ["-1", "0", "1", "100", "0.2"];
+    expect.assertions(inputs.length);
+
+    inputs.forEach((input) => {
+      const output = toNumberWithDefaultZero(input);
+      expect(output).toBe(Number(input));
+    });
+  });
+
+  it("return zero if input is not a number", () => {
+    const inputs = [
+      "vfdvf",
+      "5n",
+      "-5n",
+      null,
+      undefined,
+      NaN,
+      "",
+      {},
+      { test: 1 },
+      [],
+      [1],
+    ];
+
+    expect.assertions(inputs.length);
+
+    inputs.forEach((input) => {
+      const output = toNumberWithDefaultZero(input);
+      expect(output).toBe(DEFAULT);
+    });
+  });
+});

package/numberUtils/index.ts

@@ -1,18 +1,37 @@
-import * as R from "ramda";
+import { isNil } from "@applicaster/zapp-react-native-utils/utils";
+
 import { logger } from "@applicaster/zapp-react-native-utils/logger";
 
 const numberUtilsLogger = logger?.addSubsystem("NumberUtils");
 
+/** Matches Ramda isEmpty: "" / [] / {} are empty; numbers and bigints are not. */
+const isEmpty = (value: unknown): boolean => {
+  if (typeof value === "string" || Array.isArray(value)) {
+    return value.length === 0;
+  }
+
+  if (typeof value === "object" && value !== null) {
+    return Object.keys(value).length === 0;
+  }
+
+  return false;
+};
+
 export const toNumber = (value: unknown): number | undefined => {
-  if (R.isNil(value) || R.isEmpty(value)) {
+  if (isNil(value) || isEmpty(value)) {
     return undefined;
   }
 
   // Feature-detect BigInt support to avoid ReferenceError on older runtimes
   const isBigIntSupported = typeof BigInt !== "undefined";
-  const isBigIntValue = isBigIntSupported && R.is(BigInt, value);
-
-  if (R.is(Number, value) || isBigIntValue || R.is(String, value)) {
+  const isBigIntValue = isBigIntSupported && typeof value === "bigint";
+
+  if (
+    typeof value === "number" ||
+    isBigIntValue ||
+    typeof value === "string" ||
+    value instanceof String
+  ) {
     const numberOrNan = Number(value);
 
     return Number.isNaN(numberOrNan) ? undefined : numberOrNan;
@@ -59,7 +78,7 @@ export const toFiniteNumberWithDefault = (
 export const isLikeNumber = (value: unknown): boolean => {
   const possibleNumber = toNumber(value);
 
-  if (R.isNil(possibleNumber)) {
+  if (isNil(possibleNumber)) {
     return false;
   }
 
@@ -76,7 +95,7 @@ export const isMinusZero = (value: number) => {
 export const toPositiveNumber = (value: unknown): number | undefined => {
   const possibleNumber = toNumber(value);
 
-  if (R.isNil(possibleNumber)) {
+  if (isNil(possibleNumber)) {
     return undefined;
   }
 
@@ -97,7 +116,7 @@ export const toPositiveNumberWithDefault = (
 ): number => {
   const possibleNumber = toNumber(value);
 
-  if (R.isNil(possibleNumber)) {
+  if (isNil(possibleNumber)) {
     return defaultValue;
   }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@applicaster/zapp-react-native-utils",
-  "version": "16.0.0-rc.7",
+  "version": "16.0.0-rc.71",
   "description": "Applicaster Zapp React Native utilities package",
   "main": "index.js",
   "types": "index.d.ts",
@@ -27,7 +27,7 @@
   },
   "homepage": "https://github.com/applicaster/quickbrick#readme",
   "dependencies": {
-    "@applicaster/applicaster-types": "16.0.0-rc.7",
+    "@applicaster/applicaster-types": "16.0.0-rc.71",
     "buffer": "^5.2.1",
     "camelize": "^1.0.0",
     "dayjs": "^1.11.10",

package/pipesUtils/__tests__/buildUrlWithQuery.test.ts

@@ -0,0 +1,33 @@
+import { buildUrlWithQuery } from "../withPipesEndpoint";
+
+describe("buildUrlWithQuery", () => {
+  it("returns the url unchanged when requestParams is null", () => {
+    expect(buildUrlWithQuery("https://foo.com/path", null)).toBe(
+      "https://foo.com/path"
+    );
+  });
+
+  it("returns the url unchanged when requestParams has no params", () => {
+    expect(buildUrlWithQuery("https://foo.com/path", { headers: {} })).toBe(
+      "https://foo.com/path"
+    );
+  });
+
+  it("returns the url unchanged when url is empty", () => {
+    expect(buildUrlWithQuery("", { params: { a: "1" } })).toBe("");
+  });
+
+  it("appends params to a url with no existing query", () => {
+    expect(
+      buildUrlWithQuery("https://foo.com/path", { params: { token: "abc" } })
+    ).toBe("https://foo.com/path?token=abc");
+  });
+
+  it("merges params with an existing query string", () => {
+    expect(
+      buildUrlWithQuery("https://foo.com/path?existing=1", {
+        params: { token: "abc" },
+      })
+    ).toBe("https://foo.com/path?existing=1&token=abc");
+  });
+});

package/pipesUtils/__tests__/withPipesEndpoint.test.tsx

@@ -0,0 +1,56 @@
+import * as React from "react";
+import { render } from "@testing-library/react-native";
+import { Text } from "react-native";
+
+const mockedUseBuildPipesUrl = jest.fn();
+
+jest.mock("@applicaster/zapp-react-native-utils/reactHooks/feed", () => ({
+  useBuildPipesUrl: (args) => mockedUseBuildPipesUrl(args),
+}));
+
+const { withPipesEndpoint } = require("../withPipesEndpoint");
+
+// eslint-disable-next-line react/display-name
+const Wrapped = React.forwardRef((props: any, _ref) => (
+  <Text testID="wrapped">{`${props.uri}|${JSON.stringify(props.headers)}`}</Text>
+));
+
+describe("withPipesEndpoint", () => {
+  afterEach(() => jest.clearAllMocks());
+
+  it("renders nothing while the endpoint context is resolving", () => {
+    mockedUseBuildPipesUrl.mockReturnValue({ requestParams: null });
+
+    const Decorated = withPipesEndpoint(Wrapped);
+    const { queryByTestId } = render(<Decorated uri="https://foo.com" />);
+
+    expect(queryByTestId("wrapped")).toBeNull();
+  });
+
+  it("passes the uri through unchanged when there are no params", () => {
+    mockedUseBuildPipesUrl.mockReturnValue({ requestParams: {} });
+
+    const Decorated = withPipesEndpoint(Wrapped);
+    const { getByTestId } = render(<Decorated uri="https://foo.com/path" />);
+
+    expect(getByTestId("wrapped").props.children).toBe(
+      "https://foo.com/path|{}"
+    );
+  });
+
+  it("merges resolved params into the uri and forwards headers", () => {
+    mockedUseBuildPipesUrl.mockReturnValue({
+      requestParams: {
+        params: { token: "abc" },
+        headers: { Authorization: "Bearer xyz" },
+      },
+    });
+
+    const Decorated = withPipesEndpoint(Wrapped);
+    const { getByTestId } = render(<Decorated uri="https://foo.com/path" />);
+
+    expect(getByTestId("wrapped").props.children).toBe(
+      'https://foo.com/path?token=abc|{"Authorization":"Bearer xyz"}'
+    );
+  });
+});

package/pipesUtils/index.ts

@@ -0,0 +1 @@
+export { withPipesEndpoint, buildUrlWithQuery } from "./withPipesEndpoint";

package/pipesUtils/withPipesEndpoint.tsx

@@ -0,0 +1,54 @@
+import React, { forwardRef, RefObject } from "react";
+import URL from "url";
+
+import { useBuildPipesUrl } from "@applicaster/zapp-react-native-utils/reactHooks/feed";
+
+/**
+ * Merges the query params resolved from a pipes endpoint context into the url.
+ * Returns the url unchanged when there is nothing to merge.
+ */
+export function buildUrlWithQuery(url: string, requestParams): string {
+  if (!url || !requestParams?.params) {
+    return url;
+  }
+
+  const parsedURL = URL.parse(url, true);
+
+  parsedURL.query = { ...parsedURL.query, ...requestParams.params };
+  parsedURL.search = null;
+
+  return URL.format(parsedURL);
+}
+
+type Props = {
+  uri: string;
+} & Record<string, unknown>;
+
+/**
+ * HOC that resolves the wrapped component's `uri` against its matching Zapp
+ * Pipes endpoint. Endpoint context keys are added as query params (merged into
+ * the uri) and as request `headers`. Rendering is deferred until the context
+ * has been resolved so the component never loads without its required headers.
+ */
+export function withPipesEndpoint(Component) {
+  function WithPipesEndpoint(props: Props, ref: RefObject<unknown>) {
+    const { requestParams } = useBuildPipesUrl({ url: props.uri });
+
+    if (requestParams !== null) {
+      const urlWithQuery = buildUrlWithQuery(props.uri, requestParams);
+
+      return (
+        <Component
+          ref={ref}
+          {...props}
+          uri={urlWithQuery}
+          headers={requestParams.headers || {}}
+        />
+      );
+    }
+
+    return null;
+  }
+
+  return forwardRef(WithPipesEndpoint);
+}