@entropy-softworks/ui 2026.7.31

package/src/flags.ts

@@ -0,0 +1,44 @@
+// Build-time feature flags shared across Entropy Softworks apps.
+//
+// Expo inlines `EXPO_PUBLIC_*` env vars at bundle time, so these resolve to
+// constants in each app's build. Both default OFF-state when unset:
+//
+//   EXPO_PUBLIC_DISABLE_BRANDING  default false → Entropy branding shown.
+//     Self-hosters may set "true" to strip Entropy logo / boot splash /
+//     "An Entropy Softworks product" byline + entropy-related legal content.
+//     It does NOT touch the product's own logo/branding. SaaS ships "false".
+//
+//   EXPO_PUBLIC_ENABLE_LICENSING  default false → no licensing gate active.
+//     SaaS production ships "true" and a separate app supplies the actual
+//     licensing/subscription integration. Self-hosters leave it off; the gate
+//     wiring is present everywhere either way.
+//
+// INVARIANT: licensing requires Entropy branding. Licensing is only ever used
+// by Entropy's own SaaS deployments, which always carry the company branding
+// and legal content — so ENABLE_LICENSING is coerced off (with a warning)
+// whenever DISABLE_BRANDING is set. There is no valid unbranded+licensed
+// configuration.
+
+export const DISABLE_BRANDING = process.env.EXPO_PUBLIC_DISABLE_BRANDING === "true";
+
+const RAW_ENABLE_LICENSING = process.env.EXPO_PUBLIC_ENABLE_LICENSING === "true";
+
+export const ENABLE_LICENSING = RAW_ENABLE_LICENSING && !DISABLE_BRANDING;
+
+if (RAW_ENABLE_LICENSING && DISABLE_BRANDING) {
+  console.warn(
+    "[entropy-ui] EXPO_PUBLIC_ENABLE_LICENSING ignored: licensing requires " +
+      "Entropy branding and legal content (EXPO_PUBLIC_DISABLE_BRANDING must " +
+      "be false). Licensing has been disabled for this build."
+  );
+}
+
+/** True when Entropy company branding should render (the common case). */
+export function brandingEnabled(): boolean {
+  return !DISABLE_BRANDING;
+}
+
+/** Licensing flag + (future) status. Hook form for ergonomic consumption. */
+export function useLicensing(): { enabled: boolean } {
+  return { enabled: ENABLE_LICENSING };
+}

package/src/forms/form-error.tsx

@@ -0,0 +1,20 @@
+import React from "react";
+import { View } from "react-native";
+import { ErrorText } from "../components/text";
+
+interface FormErrorProps {
+  message?: string;
+}
+
+/**
+ * Fixed-height slot for a single form-level error message. Always
+ * rendered so the form layout does not shift when errors appear or
+ * clear.
+ */
+export default function FormError({ message }: FormErrorProps) {
+  return (
+    <View style={{ minHeight: 20, justifyContent: "center" }}>
+      {message ? <ErrorText className="text-center">{message}</ErrorText> : null}
+    </View>
+  );
+}

package/src/forms/index.ts

@@ -0,0 +1,2 @@
+export { default as FormError } from "./form-error";
+export { default as ShakeField } from "./shake-field";

package/src/forms/shake-field.tsx

@@ -0,0 +1,52 @@
+import React from "react";
+import { View } from "react-native";
+import Animated from "react-native-reanimated";
+import { Label } from "../components/text";
+import { type useShakeAnimation } from "../hooks/useShakeAnimation";
+
+type ShakeControl = ReturnType<typeof useShakeAnimation>;
+
+interface ShakeFieldProps {
+  shake: ShakeControl;
+  label?: string;
+  children: React.ReactNode;
+  flashRadius?: number;
+  /** When `false`, only the red flash runs — no rotation. Defaults to `true`. */
+  rotate?: boolean;
+}
+
+/**
+ * Wraps a form field so it can shake + flash red when validation fails.
+ * The label renders outside the shake wrapper so only the input rocks.
+ */
+export default function ShakeField({
+  shake,
+  label,
+  children,
+  flashRadius = 8,
+  rotate = true,
+}: ShakeFieldProps) {
+  return (
+    <View>
+      {label ? <Label className="mb-2">{label}</Label> : null}
+      <Animated.View style={[rotate ? shake.animatedStyle : undefined, { position: "relative" }]}>
+        {children}
+        <Animated.View
+          style={[
+            shake.flashStyle,
+            {
+              pointerEvents: "none",
+              position: "absolute",
+              left: 0,
+              right: 0,
+              top: 0,
+              bottom: 0,
+              borderRadius: flashRadius,
+              backgroundColor: "#EF4444",
+            },
+          ]}
+        />
+      </Animated.View>
+    </View>
+  );
+}

package/src/hooks/__tests__/useUploadBlobUrl.test.tsx

@@ -0,0 +1,77 @@
+/**
+ * Behavioural tests for `useUploadBlobUrl`. The hook is exercised
+ * through `renderHook` from `@testing-library/react-native`, with the
+ * package's `apiFetch` mocked so we can drive successful and failing
+ * upload fetches deterministically.
+ */
+import { act, renderHook, waitFor } from "@testing-library/react-native";
+
+import { apiFetch } from "../../utils/api-fetch";
+import { useUploadBlobUrl } from "../useUploadBlobUrl";
+
+jest.mock("../../utils/api-fetch", () => ({
+  apiFetch: jest.fn(),
+}));
+
+const apiFetchMock = apiFetch as jest.MockedFunction<typeof apiFetch>;
+
+const originalCreateObjectURL = globalThis.URL.createObjectURL;
+const originalRevokeObjectURL = globalThis.URL.revokeObjectURL;
+let urlCounter = 0;
+const revokedUrls: string[] = [];
+
+beforeEach(() => {
+  apiFetchMock.mockReset();
+  urlCounter = 0;
+  revokedUrls.length = 0;
+  globalThis.URL.createObjectURL = jest.fn(() => `blob:test/${++urlCounter}`);
+  globalThis.URL.revokeObjectURL = jest.fn((u: string) => {
+    revokedUrls.push(u);
+  });
+});
+afterAll(() => {
+  globalThis.URL.createObjectURL = originalCreateObjectURL;
+  globalThis.URL.revokeObjectURL = originalRevokeObjectURL;
+});
+
+describe("useUploadBlobUrl", () => {
+  it("returns null while idle", () => {
+    const { result } = renderHook(() => useUploadBlobUrl(null));
+    expect(result.current.uri).toBeNull();
+    expect(result.current.errored).toBe(false);
+  });
+
+  it("resolves a blob URL on a successful fetch", async () => {
+    apiFetchMock.mockResolvedValueOnce(new Response(new Blob(["ok"]), { status: 200 }));
+    const { result } = renderHook(() => useUploadBlobUrl("abc"));
+    await waitFor(() => {
+      expect(result.current.uri).toMatch(/^blob:test\//);
+    });
+    expect(result.current.errored).toBe(false);
+  });
+
+  it("marks errored when the fetch fails", async () => {
+    apiFetchMock.mockResolvedValueOnce(new Response("nope", { status: 500 }));
+    const { result } = renderHook(() => useUploadBlobUrl("abc"));
+    await waitFor(() => {
+      expect(result.current.errored).toBe(true);
+    });
+    expect(result.current.uri).toBeNull();
+  });
+
+  it("revokes the blob URL on unmount", async () => {
+    apiFetchMock.mockResolvedValueOnce(new Response(new Blob(["ok"]), { status: 200 }));
+    const { result, unmount } = renderHook(() => useUploadBlobUrl("abc"));
+    await waitFor(() => {
+      expect(result.current.uri).not.toBeNull();
+    });
+    const uri = result.current.uri;
+    if (uri === null) {
+      throw new Error("uri not set");
+    }
+    act(() => {
+      unmount();
+    });
+    expect(revokedUrls).toContain(uri);
+  });
+});

package/src/hooks/index.ts

@@ -0,0 +1,18 @@
+export {
+  AuthProvider,
+  useAuth,
+  useRole,
+  useRequireAuth,
+  useSession,
+  type AuthProviderProps,
+  type AuthContextType,
+  type PasskeyLoginResult,
+} from "./useAuth";
+
+export { useShakeAnimation } from "./useShakeAnimation";
+
+export { useDebouncedValue } from "./useDebouncedValue";
+
+export { useAutoLock, type UseAutoLockOptions } from "./useAutoLock";
+
+export { useUploadBlobUrl, type UploadBlobUrlResult } from "./useUploadBlobUrl";