@mr.dj2u/library-registry 0.2.0 → 0.3.0

package/assets/mds/src/features/onboarding-state/onboarding-state-zustand.ts

@@ -0,0 +1,71 @@
+import {
+  createEmptyOnboardingState,
+  upsertLegalAcceptance,
+  type OnboardingState,
+  type OnboardingStateAdapter,
+} from './onboarding-state-types';
+import {
+  getPersistedOnboardingState,
+  setPersistedOnboardingState,
+} from './onboarding-store';
+import type { MemoryLegalAcceptanceAdapter, MemoryLegalDocument } from './onboarding-state-memory';
+
+export function createZustandOnboardingStateAdapter(): OnboardingStateAdapter {
+  return {
+    mode: 'zustand-local',
+    async loadState() {
+      const state = getPersistedOnboardingState();
+      return { ...state, legalAcceptances: [...state.legalAcceptances] };
+    },
+    async saveState(state: OnboardingState) {
+      setPersistedOnboardingState({
+        ...state,
+        legalAcceptances: [...state.legalAcceptances],
+        pendingSync: false,
+      });
+    },
+    async markComplete(input) {
+      const current = getPersistedOnboardingState();
+      const next = {
+        ...current,
+        completedAt: input?.completedAt ?? new Date().toISOString(),
+        currentStep: 'complete',
+        pendingSync: false,
+      };
+      setPersistedOnboardingState(next);
+      return next;
+    },
+  };
+}
+
+export function createZustandLegalAcceptanceAdapter(): MemoryLegalAcceptanceAdapter {
+  return {
+    async loadRequiredLegalAcceptances(requiredDocuments: MemoryLegalDocument[]) {
+      const acceptedDocumentKeys = getPersistedOnboardingState().legalAcceptances.map(
+        (item) => `${item.documentId}@${item.documentVersion}`,
+      );
+      const accepted = new Set(acceptedDocumentKeys);
+      const missingDocuments = requiredDocuments.filter(
+        (document) => !accepted.has(`${document.documentId}@${document.acceptanceVersion}`),
+      );
+
+      return {
+        status: missingDocuments.length > 0 ? 'needs-legal' : 'complete',
+        requiredDocuments: missingDocuments,
+        acceptedDocumentKeys,
+      };
+    },
+
+    async acceptLegalDocument(document, input) {
+      const next = upsertLegalAcceptance(getPersistedOnboardingState() ?? createEmptyOnboardingState(), {
+        documentId: document.documentId,
+        documentVersion: document.acceptanceVersion,
+        acceptedAt: new Date().toISOString(),
+        userId: input?.userId,
+        flowId: input?.flowId,
+        flowVersion: input?.flowVersion,
+      });
+      setPersistedOnboardingState(next);
+    },
+  };
+}

package/assets/mds/src/features/onboarding-state/onboarding-state.ts

@@ -0,0 +1,22 @@
+import './onboarding-state-adapter';
+
+export {
+  configureOnboardingStateAdapter,
+  getOnboardingStateAdapter,
+  markOnboardingComplete,
+  setOnboardingStateUserId,
+  subscribeToOnboardingStateChanges,
+  useOnboardingState,
+} from './onboarding-state-core';
+export {
+  DEFAULT_ONBOARDING_FLOW_ID,
+  DEFAULT_ONBOARDING_FLOW_VERSION,
+  createEmptyOnboardingState,
+  upsertLegalAcceptance,
+} from './onboarding-state-types';
+export type {
+  OnboardingDocumentAcceptance,
+  OnboardingPersistenceMode,
+  OnboardingState,
+  OnboardingStateAdapter,
+} from './onboarding-state-types';

package/assets/mds/src/features/onboarding-state/onboarding-store.ts

@@ -0,0 +1,39 @@
+import AsyncStorage from '@react-native-async-storage/async-storage';
+import { create } from 'zustand';
+import { createJSONStorage, persist } from 'zustand/middleware';
+
+import {
+  createEmptyOnboardingState,
+  type OnboardingState,
+} from './onboarding-state-types';
+
+type OnboardingStore = {
+  state: OnboardingState;
+  setOnboardingState: (state: OnboardingState) => void;
+};
+
+export const useOnboardingStore = create<OnboardingStore>()(
+  persist(
+    (set) => ({
+      state: createEmptyOnboardingState(),
+      setOnboardingState: (state) => set({ state }),
+    }),
+    {
+      name: 'mds.onboarding.state.v1',
+      storage: createJSONStorage(() => AsyncStorage),
+      partialize: (value) => ({ state: value.state }),
+    },
+  ),
+);
+
+export function getPersistedOnboardingState(): OnboardingState {
+  return useOnboardingStore.getState().state;
+}
+
+export function setPersistedOnboardingState(state: OnboardingState): void {
+  useOnboardingStore.getState().setOnboardingState(state);
+}
+
+export function subscribeToPersistedOnboardingState(listener: () => void): () => void {
+  return useOnboardingStore.subscribe(listener);
+}

package/assets/mds/src/features/settings/settings-screen-logic.ts

@@ -0,0 +1,122 @@
+import type { AuthAdapter } from '../auth/auth-types';
+
+export interface SettingsLegalUrls {
+  privacy?: string;
+  terms?: string;
+  gdpr?: string;
+}
+
+export interface SettingsVersionInfo {
+  version: string;
+  build?: string;
+}
+
+export interface SettingsLinkItem {
+  id: string;
+  label: string;
+  href: string;
+  description: string;
+}
+
+export interface SettingsConstantsShape {
+  expoConfig?: {
+    version?: string;
+    ios?: { buildNumber?: string | null };
+    android?: { versionCode?: number | null };
+  } | null;
+  nativeAppVersion?: string | null;
+  nativeBuildVersion?: string | null;
+}
+
+export function resolveSettingsVersionInfo(
+  source: SettingsConstantsShape
+): SettingsVersionInfo {
+  const version =
+    source.expoConfig?.version ?? source.nativeAppVersion ?? 'Development build';
+  const build =
+    source.nativeBuildVersion ??
+    source.expoConfig?.ios?.buildNumber ??
+    (typeof source.expoConfig?.android?.versionCode === 'number'
+      ? String(source.expoConfig.android.versionCode)
+      : undefined);
+
+  return { version, ...(build ? { build } : {}) };
+}
+
+export function buildSettingsLinkItems(
+  legalUrls?: SettingsLegalUrls,
+  profileHref?: string
+): SettingsLinkItem[] {
+  return [
+    ...(profileHref
+      ? [
+          {
+            id: 'profile',
+            label: 'Manage profile',
+            href: profileHref,
+            description: 'Open the account or profile surface for this app.',
+          },
+        ]
+      : []),
+    ...(legalUrls?.terms
+      ? [
+          {
+            id: 'terms',
+            label: 'Terms of Service',
+            href: legalUrls.terms,
+            description: 'Review service usage, account, and policy terms.',
+          },
+        ]
+      : []),
+    ...(legalUrls?.privacy
+      ? [
+          {
+            id: 'privacy',
+            label: 'Privacy Policy',
+            href: legalUrls.privacy,
+            description: 'Review data processing, retention, and user choices.',
+          },
+        ]
+      : []),
+    ...(legalUrls?.gdpr
+      ? [
+          {
+            id: 'gdpr',
+            label: 'GDPR Notice',
+            href: legalUrls.gdpr,
+            description: 'Review data-subject rights, exports, and deletion requests.',
+          },
+        ]
+      : []),
+  ];
+}
+
+export function createPlaceholderAuthAdapter(
+  provider: AuthAdapter['provider'] = 'base'
+): AuthAdapter {
+  return {
+    provider,
+    state: { isLoading: false, session: null },
+    refreshSession: async () => {},
+    signInWithEmailPassword: async () => ({
+      ok: false,
+      error: 'Install and wire the auth library before using sign-in from Settings.',
+    }),
+    signUpWithEmailPassword: async () => ({
+      ok: false,
+      error: 'Install and wire the auth library before using sign-up from Settings.',
+    }),
+    requestPasswordReset: async () => ({
+      ok: false,
+      error: 'Install and wire the auth library before using password reset from Settings.',
+    }),
+    signOut: async () => ({
+      ok: true,
+      message: 'No auth provider is configured for this generated Settings screen yet.',
+    }),
+  };
+}
+
+export async function performSettingsSignOut(auth: AuthAdapter) {
+  return auth.signOut();
+}

package/assets/mds/src/features/settings/settings-screen.tsx

@@ -1,57 +1,303 @@
-import { StyleSheet, Text, View } from 'react-native';
+import type { Href } from 'expo-router';
+import { useRouter } from 'expo-router';
+import Constants from 'expo-constants';
+import { useMemo, useState } from 'react';
+import { Linking, Pressable, ScrollView, StyleSheet, Text, View } from 'react-native';
 
-import { KeyboardForm } from '../../components/swmansion/keyboard-form';
+import { getReadableTextColor } from '../../theme/color-utils';
 import { useAppTheme } from '../../theme/provider';
+import {
+  buildSettingsLinkItems,
+  createPlaceholderAuthAdapter,
+  performSettingsSignOut,
+  resolveSettingsVersionInfo as resolveSettingsVersionInfoFromConstants,
+  type SettingsConstantsShape,
+  type SettingsLegalUrls,
+} from './settings-screen-logic';
 
-export default function SettingsScreen() {
+import type { AuthAdapter } from '../auth/auth-types';
+
+export interface SettingsScreenProps {
+  auth: AuthAdapter;
+  legalUrls?: SettingsLegalUrls;
+  profileHref?: string;
+}
+
+export function resolveSettingsVersionInfo(
+  source: SettingsConstantsShape = Constants as SettingsConstantsShape
+){
+  return resolveSettingsVersionInfoFromConstants(source);
+}
+
+function resolveInternalSettingsHref(href: string): Href | null {
+  if (href.startsWith('/')) {
+    return href as Href;
+  }
+  if (typeof window === 'undefined') {
+    return null;
+  }
+  try {
+    const url = new URL(href, window.location.origin);
+    if (url.origin !== window.location.origin) {
+      return null;
+    }
+    return `${url.pathname}${url.search}${url.hash}` as Href;
+  } catch {
+    return null;
+  }
+}
+
+async function openSettingsHref(href: string, push: (href: Href) => void): Promise<void> {
+  const internalHref = resolveInternalSettingsHref(href);
+  if (internalHref) {
+    push(internalHref);
+    return;
+  }
+  await Linking.openURL(href);
+}
+
+export default function SettingsScreen({
+  auth,
+  legalUrls,
+  profileHref,
+}: SettingsScreenProps) {
+  const router = useRouter();
   const theme = useAppTheme();
   const colors = theme.activeColors;
+  const user = auth.state.session?.user ?? null;
+  const versionInfo = useMemo(() => resolveSettingsVersionInfo(), []);
+  const links = useMemo(
+    () => buildSettingsLinkItems(legalUrls, profileHref),
+    [legalUrls, profileHref]
+  );
+  const [notice, setNotice] = useState<string | null>(null);
+  const [isSigningOut, setIsSigningOut] = useState(false);
+  const dangerForeground = getReadableTextColor(colors.warning, theme.colors.light.text);
+
+  async function handleSignOut() {
+    if (isSigningOut) {
+      return;
+    }
+    setIsSigningOut(true);
+    setNotice(null);
+    const result = await performSettingsSignOut(auth);
+    setIsSigningOut(false);
+    setNotice(result.ok ? result.message ?? 'Signed out.' : result.error);
+  }
 
   return (
-    <View style={[styles.screen, { backgroundColor: colors.background }]}>
-      <View style={styles.header}>
-        <Text
+    <ScrollView
+      contentInsetAdjustmentBehavior="automatic"
+      contentContainerStyle={styles.content}
+      style={[styles.screen, { backgroundColor: colors.background }]}>
+      <View
+        style={[
+          styles.panel,
+          {
+            backgroundColor: colors.surface,
+            borderColor: colors.primary,
+            borderRadius: theme.layout.radius,
+          },
+        ]}>
+        <View style={styles.header}>
+          <Text
+            style={[
+              styles.title,
+              {
+                color: colors.text,
+                fontFamily: theme.typography.fontTitle,
+              },
+            ]}>
+            Settings
+          </Text>
+          <Text style={[styles.body, { color: colors.text }]}>
+            Review account details, legal documents, and release information in one place.
+          </Text>
+        </View>
+
+        <View
           style={[
-            styles.title,
+            styles.card,
             {
-              color: colors.text,
-              fontFamily: theme.typography.fontFamily,
-              fontWeight:
-                theme.typography.fontFamily === 'System' ||
-                theme.typography.fontFamily === 'monospace'
-                  ? '800'
-                  : 'normal',
+              backgroundColor: colors.background,
+              borderColor: colors.primary,
+              borderRadius: theme.layout.radius,
             },
           ]}>
-          Settings
-        </Text>
-        <Text style={[styles.body, { color: colors.text }]}>
-          Keyboard Controller is ready for form-heavy screens.
-        </Text>
+          <Text style={[styles.sectionLabel, { color: colors.primary }]}>Account</Text>
+          <Text style={[styles.accountTitle, { color: colors.text }]}>
+            {user?.name?.trim() || user?.email?.trim() || 'Signed-out preview'}
+          </Text>
+          <Text style={[styles.accountMeta, { color: colors.text }]}>
+            {user?.email?.trim() || 'No authenticated session is active.'}
+          </Text>
+          <Text style={[styles.accountMeta, { color: colors.text }]}>
+            Provider: {user?.provider || auth.provider}
+          </Text>
+        </View>
+
+        {links.length > 0 ? (
+          <View style={styles.section}>
+            <Text style={[styles.sectionLabel, { color: colors.primary }]}>Links</Text>
+            <View style={styles.linkStack}>
+              {links.map((item) => (
+                <Pressable
+                  key={item.id}
+                  accessibilityRole="button"
+                  onPress={() => void openSettingsHref(item.href, router.push)}
+                  style={[
+                    styles.linkCard,
+                    {
+                      backgroundColor: colors.background,
+                      borderColor: colors.primary,
+                      borderRadius: theme.layout.radius,
+                    },
+                  ]}>
+                  <Text style={[styles.linkLabel, { color: colors.text }]}>{item.label}</Text>
+                  <Text style={[styles.linkDescription, { color: colors.text }]}>
+                    {item.description}
+                  </Text>
+                </Pressable>
+              ))}
+            </View>
+          </View>
+        ) : null}
+
+        <View style={styles.section}>
+          <Text style={[styles.sectionLabel, { color: colors.primary }]}>App info</Text>
+          <View
+            style={[
+              styles.card,
+              {
+                backgroundColor: colors.background,
+                borderColor: colors.primary,
+                borderRadius: theme.layout.radius,
+              },
+            ]}>
+            <Text style={[styles.accountTitle, { color: colors.text }]}>
+              Version {versionInfo.version}
+            </Text>
+            {versionInfo.build ? (
+              <Text style={[styles.accountMeta, { color: colors.text }]}>
+                Build {versionInfo.build}
+              </Text>
+            ) : null}
+          </View>
+        </View>
+
+        <View style={styles.actions}>
+          <Pressable
+            accessibilityRole="button"
+            disabled={!user || isSigningOut}
+            onPress={() => void handleSignOut()}
+            style={[
+              styles.primaryButton,
+              {
+                backgroundColor: user ? colors.warning : colors.surface,
+                borderRadius: theme.layout.radius,
+                opacity: !user || isSigningOut ? 0.7 : 1,
+              },
+            ]}>
+            <Text
+              style={[
+                styles.primaryButtonText,
+                { color: user ? dangerForeground : colors.text },
+              ]}>
+              {isSigningOut ? 'Signing out...' : 'Sign Out'}
+            </Text>
+          </Pressable>
+        </View>
+
+        {notice ? <Text style={[styles.notice, { color: colors.text }]}>{notice}</Text> : null}
       </View>
-      <KeyboardForm />
-    </View>
+    </ScrollView>
   );
 }
 
 const styles = StyleSheet.create({
   screen: {
-    backgroundColor: '#ffffff',
     flex: 1,
+  },
+  content: {
+    flexGrow: 1,
+    justifyContent: 'center',
     padding: 20,
   },
+  panel: {
+    alignSelf: 'center',
+    borderWidth: 1,
+    gap: 18,
+    maxWidth: 760,
+    padding: 18,
+    width: '100%',
+  },
   header: {
-    marginBottom: 12,
+    gap: 6,
   },
   title: {
-    color: '#111827',
-    fontSize: 26,
-    fontWeight: '800',
+    fontSize: 30,
+    fontWeight: '900',
+    lineHeight: 36,
   },
   body: {
-    color: '#4b5563',
+    fontSize: 15,
+    lineHeight: 22,
+  },
+  section: {
+    gap: 10,
+  },
+  sectionLabel: {
+    fontSize: 12,
+    fontWeight: '900',
+    textTransform: 'uppercase',
+  },
+  card: {
+    borderWidth: 1,
+    gap: 6,
+    padding: 14,
+  },
+  accountTitle: {
+    fontSize: 18,
+    fontWeight: '900',
+  },
+  accountMeta: {
     fontSize: 14,
     lineHeight: 20,
-    marginTop: 4,
+  },
+  linkStack: {
+    gap: 10,
+  },
+  linkCard: {
+    borderWidth: 1,
+    gap: 4,
+    padding: 14,
+  },
+  linkLabel: {
+    fontSize: 15,
+    fontWeight: '900',
+  },
+  linkDescription: {
+    fontSize: 13,
+    lineHeight: 18,
+  },
+  actions: {
+    flexDirection: 'row',
+    flexWrap: 'wrap',
+    gap: 10,
+  },
+  primaryButton: {
+    alignItems: 'center',
+    justifyContent: 'center',
+    minHeight: 48,
+    minWidth: 160,
+    paddingHorizontal: 16,
+  },
+  primaryButtonText: {
+    fontSize: 15,
+    fontWeight: '900',
+  },
+  notice: {
+    fontSize: 13,
+    lineHeight: 19,
   },
 });

package/assets/mds/src/services/convex.ts

@@ -0,0 +1,40 @@
+import { ConvexReactClient } from 'convex/react';
+import * as SecureStore from 'expo-secure-store';
+import { Platform } from 'react-native';
+
+const convexUrl = process.env.EXPO_PUBLIC_CONVEX_URL;
+export const isConvexConfigured = Boolean(convexUrl);
+
+let convexClient: ConvexReactClient | null = null;
+
+export function getConvexClient(): ConvexReactClient {
+  if (!convexUrl) {
+    throw new Error('Set EXPO_PUBLIC_CONVEX_URL before using Convex Auth.');
+  }
+
+  convexClient ??= new ConvexReactClient(convexUrl);
+  return convexClient;
+}
+
+export const convexAuthStorage = {
+  async getItem(key: string) {
+    if (Platform.OS === 'web') {
+      return globalThis.localStorage?.getItem(key) ?? null;
+    }
+    return SecureStore.getItemAsync(key);
+  },
+  async setItem(key: string, value: string) {
+    if (Platform.OS === 'web') {
+      globalThis.localStorage?.setItem(key, value);
+      return;
+    }
+    await SecureStore.setItemAsync(key, value);
+  },
+  async removeItem(key: string) {
+    if (Platform.OS === 'web') {
+      globalThis.localStorage?.removeItem(key);
+      return;
+    }
+    await SecureStore.deleteItemAsync(key);
+  },
+};

package/assets/mds/src/services/firebase.ts

@@ -0,0 +1,70 @@
+import AsyncStorage from '@react-native-async-storage/async-storage';
+import { getApp, getApps, initializeApp } from 'firebase/app';
+import { getAuth, getReactNativePersistence, initializeAuth } from 'firebase/auth';
+import { getFirestore } from 'firebase/firestore';
+
+import type { FirebaseApp } from 'firebase/app';
+import type { Auth } from 'firebase/auth';
+import type { Firestore } from 'firebase/firestore';
+
+const firebaseConfig = {
+  apiKey: process.env.EXPO_PUBLIC_FIREBASE_API_KEY,
+  authDomain: process.env.EXPO_PUBLIC_FIREBASE_AUTH_DOMAIN,
+  projectId: process.env.EXPO_PUBLIC_FIREBASE_PROJECT_ID,
+  storageBucket: process.env.EXPO_PUBLIC_FIREBASE_STORAGE_BUCKET,
+  messagingSenderId: process.env.EXPO_PUBLIC_FIREBASE_MESSAGING_SENDER_ID,
+  appId: process.env.EXPO_PUBLIC_FIREBASE_APP_ID,
+};
+
+export const isFirebaseConfigured = Boolean(
+  firebaseConfig.apiKey &&
+    firebaseConfig.authDomain &&
+    firebaseConfig.projectId &&
+    firebaseConfig.appId,
+);
+
+export const firebaseApp: FirebaseApp | null = isFirebaseConfigured
+  ? getApps().length > 0
+    ? getApp()
+    : initializeApp(firebaseConfig)
+  : null;
+
+function createFirebaseAuth(): Auth {
+  if (!firebaseApp) {
+    throw new Error(
+      'Set EXPO_PUBLIC_FIREBASE_API_KEY, EXPO_PUBLIC_FIREBASE_AUTH_DOMAIN, EXPO_PUBLIC_FIREBASE_PROJECT_ID, and EXPO_PUBLIC_FIREBASE_APP_ID before using Firebase.',
+    );
+  }
+  try {
+    return initializeAuth(firebaseApp, {
+      persistence: getReactNativePersistence(AsyncStorage),
+    });
+  } catch {
+    return getAuth(firebaseApp);
+  }
+}
+
+export const firebaseAuth = firebaseApp ? createFirebaseAuth() : null;
+export const firebaseDb: Firestore | null = firebaseApp ? getFirestore(firebaseApp) : null;
+
+export function getFirebaseAuth(): Auth {
+  if (!isFirebaseConfigured || !firebaseAuth) {
+    throw new Error(
+      'Set EXPO_PUBLIC_FIREBASE_API_KEY, EXPO_PUBLIC_FIREBASE_AUTH_DOMAIN, EXPO_PUBLIC_FIREBASE_PROJECT_ID, and EXPO_PUBLIC_FIREBASE_APP_ID before using Firebase.',
+    );
+  }
+  return firebaseAuth;
+}
+
+export function assertFirebaseConfigured(): void {
+  void getFirebaseAuth();
+}
+
+export function getFirebaseDb(): Firestore {
+  if (!isFirebaseConfigured || !firebaseDb) {
+    throw new Error(
+      'Set EXPO_PUBLIC_FIREBASE_API_KEY, EXPO_PUBLIC_FIREBASE_AUTH_DOMAIN, EXPO_PUBLIC_FIREBASE_PROJECT_ID, and EXPO_PUBLIC_FIREBASE_APP_ID before using Firebase.',
+    );
+  }
+  return firebaseDb;
+}