@ankhorage/studio 2.0.1 → 2.0.3

package/dist/host/layout/templates/auth/form.js

@@ -0,0 +1,238 @@
+export function getAuthFormTs() {
+    return `import type { AuthIdentifier, AuthSession } from '@ankhorage/contracts/auth';
+import { isEmail, isPhone, isUsername } from '@ankhorage/utility/regex';
+import type { AuthIdentifierKind, SignUpFormField, SignUpFormValues } from '@ankhorage/zora';
+
+export interface AuthSubmitValues {
+  mode: 'signIn' | 'signUp';
+  identifier: string;
+  password: string;
+  firstName: string;
+  lastName: string;
+  displayName: string;
+}
+
+export interface IdentifierFieldDefinition {
+  helper: string;
+  keyboardType: 'default' | 'email-address' | 'phone-pad';
+  label: string;
+  placeholder: string;
+  type: 'email' | 'tel' | 'text';
+}
+
+const AUTH_IDENTIFIER_VALIDATORS = [
+  { kind: 'email', label: 'email address', matches: isEmail },
+  { kind: 'phone', label: 'phone number', matches: isPhone },
+  { kind: 'username', label: 'username', matches: isUsername },
+] as const;
+
+const OPTIONAL_SIGN_UP_FIELDS = [
+  { key: 'firstname', name: 'firstName', label: 'First name' },
+  { key: 'lastname', name: 'lastName', label: 'Last name' },
+  { key: 'displayname', name: 'displayName', label: 'Display name' },
+] as const;
+
+export function buildAuthIdentifierInput(
+  identifier: string,
+  identifiers: readonly string[],
+): AuthIdentifier | null {
+  const normalizedIdentifier = identifier.trim();
+  const resolvedIdentifiers = resolveAuthIdentifiers(identifiers);
+  const match = AUTH_IDENTIFIER_VALIDATORS.find(
+    (candidate) =>
+      resolvedIdentifiers.includes(candidate.kind) && candidate.matches(normalizedIdentifier),
+  );
+  if (match) return { kind: match.kind, value: normalizedIdentifier };
+  const [fallbackKind] = resolvedIdentifiers;
+  return fallbackKind ? { kind: fallbackKind, value: normalizedIdentifier } : null;
+}
+
+export function buildSignUpFields(args: {
+  identifierField: IdentifierFieldDefinition;
+  configuredFields: readonly string[];
+  requiredFields: readonly string[];
+}): SignUpFormField[] {
+  const { identifierField, configuredFields, requiredFields } = args;
+  const fields: SignUpFormField[] = [
+    {
+      name: 'identifier',
+      label: identifierField.label,
+      helperText: identifierField.helper,
+      placeholder: identifierField.placeholder,
+      type: identifierField.type,
+      autoCapitalize: 'none',
+      keyboardType: identifierField.keyboardType,
+      required: ['email', 'phone', 'username'].some((field) =>
+        hasConfiguredSignUpField(requiredFields, field),
+      ),
+    },
+    {
+      name: 'password',
+      label: 'Password',
+      type: 'password',
+      required: hasConfiguredSignUpField(requiredFields, 'password'),
+    },
+  ];
+  for (const definition of OPTIONAL_SIGN_UP_FIELDS) {
+    if (!hasConfiguredSignUpField(configuredFields, definition.key)) continue;
+    fields.push({
+      name: definition.name,
+      label: definition.label,
+      type: 'text',
+      required: hasConfiguredSignUpField(requiredFields, definition.key),
+    });
+  }
+  return fields;
+}
+
+export function buildSignUpProfile(args: {
+  firstName: string;
+  lastName: string;
+  displayName: string;
+}): Record<string, string> | undefined {
+  const candidates: [string, string][] = [
+    ['firstName', args.firstName.trim()],
+    ['lastName', args.lastName.trim()],
+    ['displayName', args.displayName.trim()],
+  ];
+  const entries = candidates.filter(([, value]) => value.length > 0);
+  return entries.length > 0 ? Object.fromEntries(entries) : undefined;
+}
+
+export function getFormValue(values: SignUpFormValues, name: string): string {
+  const value: unknown = Reflect.get(values, name);
+  return typeof value === 'string' ? value : '';
+}
+
+export function isAuthSession(value: unknown): value is AuthSession {
+  if (!isRecord(value)) return false;
+  const { accessToken, user } = value;
+  if (typeof accessToken !== 'string' || accessToken.length === 0 || !isRecord(user)) return false;
+  return typeof user.id === 'string' && user.id.length > 0;
+}
+
+export function resolveAuthIdentifiers(identifiers: readonly string[]): AuthIdentifierKind[] {
+  const resolved = identifiers
+    .map((identifier) => identifier.trim().toLowerCase())
+    .filter(isAuthIdentifierKind);
+  const unique = [...new Set(resolved)];
+  return unique.length > 0 ? unique : ['email'];
+}
+
+export function resolveIdentifierFieldDefinition(
+  identifiers: readonly string[],
+): IdentifierFieldDefinition {
+  const supported = new Set(resolveAuthIdentifiers(identifiers));
+  if (supported.size === 1 && supported.has('email')) {
+    return createIdentifierField(
+      'Use your email to continue.',
+      'email-address',
+      'Email',
+      'hello@example.com',
+      'email',
+    );
+  }
+  if (supported.size === 1 && supported.has('phone')) {
+    return createIdentifierField(
+      'Use your phone to continue.',
+      'phone-pad',
+      'Phone',
+      '+1 555 123 4567',
+      'tel',
+    );
+  }
+  if (supported.size === 1 && supported.has('username')) {
+    return createIdentifierField(
+      'Use your username to continue.',
+      'default',
+      'Username',
+      'your-username',
+      'text',
+    );
+  }
+  return createIdentifierField(
+    'Use your configured identifier to continue.',
+    'default',
+    supported.has('username') ? 'Identifier' : 'Email or phone',
+    'Email or phone',
+    'text',
+  );
+}
+
+export function validateAuthSubmitValues(
+  values: AuthSubmitValues,
+  identifiers: readonly string[],
+  requiredFields: readonly string[],
+): string | null {
+  const identifier = values.identifier.trim();
+  if (!identifier || values.password.length === 0)
+    return 'Enter both credentials before continuing.';
+  const identifierError = validateIdentifier(identifier, identifiers);
+  if (identifierError) return identifierError;
+  if (values.password.length < 6) return 'Password must be at least 6 characters.';
+  if (values.mode !== 'signUp') return null;
+  const missing = requiredFields.flatMap((field) =>
+    isRequiredFieldMissing(field, values) ? [fieldLabel(field)] : [],
+  );
+  return missing.length > 0 ? \`Complete required fields: \${missing.join(', ')}.\` : null;
+}
+
+function createIdentifierField(
+  helper: string,
+  keyboardType: IdentifierFieldDefinition['keyboardType'],
+  label: string,
+  placeholder: string,
+  type: IdentifierFieldDefinition['type'],
+): IdentifierFieldDefinition {
+  return { helper, keyboardType, label, placeholder, type };
+}
+
+function fieldLabel(field: string): string {
+  const normalized = field.trim().toLowerCase();
+  const definition = OPTIONAL_SIGN_UP_FIELDS.find((candidate) => candidate.key === normalized);
+  return definition?.label.toLowerCase() ?? normalized;
+}
+
+function formatList(values: readonly string[]): string {
+  if (values.length < 2) return values[0] ?? 'identifier';
+  if (values.length === 2) return \`\${values[0]} or \${values[1]}\`;
+  return \`\${values.slice(0, -1).join(', ')}, or \${values.at(-1)}\`;
+}
+
+function hasConfiguredSignUpField(fields: readonly string[], field: string): boolean {
+  return fields.some((value) => value.trim().toLowerCase() === field);
+}
+
+function isAuthIdentifierKind(value: string): value is AuthIdentifierKind {
+  return value === 'email' || value === 'phone' || value === 'username';
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+
+function isRequiredFieldMissing(field: string, values: AuthSubmitValues): boolean {
+  const normalized = field.trim().toLowerCase();
+  if (normalized === 'email' || normalized === 'username' || normalized === 'phone') {
+    return values.identifier.trim().length === 0;
+  }
+  if (normalized === 'password') return values.password.length === 0;
+  const optional = OPTIONAL_SIGN_UP_FIELDS.find((candidate) => candidate.key === normalized);
+  if (!optional) return false;
+  const value: unknown = Reflect.get(values, optional.name);
+  return typeof value !== 'string' || value.trim().length === 0;
+}
+
+function validateIdentifier(identifier: string, identifiers: readonly string[]): string | null {
+  const supported = new Set(resolveAuthIdentifiers(identifiers));
+  const allowed = AUTH_IDENTIFIER_VALIDATORS.filter((validator) => supported.has(validator.kind));
+  if (allowed.some((validator) => validator.matches(identifier))) return null;
+  const labels = allowed.map((validator) => validator.label);
+  if (labels.length === 1 && labels[0] === 'username') {
+    return 'Username must be at least 3 characters and use letters, numbers, dot, underscore, or dash.';
+  }
+  return \`Use a valid \${formatList(labels)}.\`;
+}
+`;
+}
+//# sourceMappingURL=form.js.map

package/dist/host/layout/templates/auth/form.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"form.js","sourceRoot":"","sources":["../../../../../src/host/layout/templates/auth/form.ts"],"names":[],"mappings":"AAAA,MAAM,UAAU,aAAa;IAC3B,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0OR,CAAC;AACF,CAAC"}

package/dist/host/layout/templates/auth/navigation.d.ts

@@ -0,0 +1,10 @@
+interface GetAuthNavigationTsArgs {
+    signInRoute: string;
+    signInRouteName: string;
+    signUpRouteName: string;
+    postSignInRoute: string;
+    publicRoutes: string[];
+}
+export declare function getAuthNavigationTs(args: GetAuthNavigationTsArgs): string;
+export {};
+//# sourceMappingURL=navigation.d.ts.map

package/dist/host/layout/templates/auth/navigation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"navigation.d.ts","sourceRoot":"","sources":["../../../../../src/host/layout/templates/auth/navigation.ts"],"names":[],"mappings":"AAGA,UAAU,uBAAuB;IAC/B,WAAW,EAAE,MAAM,CAAC;IACpB,eAAe,EAAE,MAAM,CAAC;IACxB,eAAe,EAAE,MAAM,CAAC;IACxB,eAAe,EAAE,MAAM,CAAC;IACxB,YAAY,EAAE,MAAM,EAAE,CAAC;CACxB;AAMD,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,uBAAuB,GAAG,MAAM,CAgLzE"}

package/dist/host/layout/templates/auth/navigation.js

@@ -0,0 +1,183 @@
+import { escapeStringLiteral } from '../../utils/escapeStringLiteral';
+import { routeNameToGroupedHref, routeNameToHref } from '../utils/routes';
+function serializeStringArrayLiteral(values) {
+    return `[${values.map((value) => `'${escapeStringLiteral(value)}'`).join(', ')}]`;
+}
+export function getAuthNavigationTs(args) {
+    return `import { type Href, usePathname, useRootNavigationState, useRouter } from 'expo-router';
+import { useCallback, useEffect, useState, useSyncExternalStore } from 'react';
+import { AppState } from 'react-native';
+
+import { authAdapter } from './adapter';
+import {
+  bootstrapAuthSession,
+  getStoredAuthSession,
+  isAuthenticated,
+  refreshAuthSessionIfNeeded,
+  subscribeToAuthSessionChanges,
+} from './session';
+
+const AUTH_SIGN_IN_ROUTE_SEGMENT = '${escapeStringLiteral(args.signInRouteName)}';
+const AUTH_SIGN_UP_ROUTE_SEGMENT = '${escapeStringLiteral(args.signUpRouteName)}';
+const AUTH_SIGN_IN_ROUTE_PATH = '${escapeStringLiteral(routeNameToHref(args.signInRoute))}';
+const AUTH_SIGN_IN_ROUTE_TARGET: Href = '${escapeStringLiteral(routeNameToGroupedHref(args.signInRoute, 'auth'))}';
+const AUTH_POST_SIGN_IN_ROUTE_PATH = '${escapeStringLiteral(routeNameToHref(args.postSignInRoute))}';
+const AUTH_POST_SIGN_IN_ROUTE_TARGET: Href = '${escapeStringLiteral(routeNameToGroupedHref(args.postSignInRoute, 'app'))}';
+const AUTH_PUBLIC_ROUTES = ${serializeStringArrayLiteral(args.publicRoutes)};
+const AUTH_DISABLE_IN_DEV = process.env.EXPO_PUBLIC_ANKH_AUTH_DISABLE_IN_DEV === 'true';
+
+export type GeneratedAuthNavigationState = 'pending' | 'unauthenticated' | 'authenticated';
+
+export function useGeneratedAuthNavigation(
+  options: { isRouteGuardDisabled?: (pathname: string) => boolean } = {},
+) {
+  const router = useRouter();
+  const rootNavigationKey = getRootNavigationKey(useRootNavigationState());
+  const pathname = usePathname();
+  const session = useSyncExternalStore(
+    subscribeToAuthSessionChanges,
+    getStoredAuthSession,
+    getStoredAuthSession,
+  );
+  const isAuthRuntimeReady = useGeneratedAuthRuntimeReady();
+  const [isInnerContentReady, setIsInnerContentReady] = useState(false);
+  const authenticated = session !== null && isAuthenticated();
+  const authState = resolveAuthNavigationState(isAuthRuntimeReady, authenticated);
+  useRefreshAuthSessionOnActive();
+  useAuthRouteGuard({
+    authenticated,
+    isAuthRuntimeReady,
+    isInnerContentReady,
+    isRouteGuardDisabled: options.isRouteGuardDisabled,
+    pathname,
+    rootNavigationKey,
+    router,
+  });
+  const handleInnerContentReady = useCallback(() => setIsInnerContentReady(true), []);
+  return { authState, handleInnerContentReady, isAuthRuntimeReady, pathname };
+}
+
+export function shouldMountAuthenticatedAppHeader(
+  pathname: string,
+  isAuthRuntimeReady: boolean,
+): boolean {
+  if (!isGeneratedAuthEnforced()) return true;
+  if (!isAuthRuntimeReady || !isAuthenticated()) return false;
+  return !isAuthRoute(pathname);
+}
+
+function useGeneratedAuthRuntimeReady(): boolean {
+  const [ready, setReady] = useState(false);
+  useEffect(() => {
+    const controller = new AbortController();
+    void initializeGeneratedAuthRuntime().then(() => {
+      if (!controller.signal.aborted) setReady(true);
+    });
+    return () => controller.abort();
+  }, []);
+  return ready;
+}
+
+async function initializeGeneratedAuthRuntime(): Promise<void> {
+  try {
+    await bootstrapAuthSession();
+    await refreshAuthSessionIfNeeded(authAdapter);
+  } catch {
+    // Storage or adapter failures resolve to the unauthenticated route instead of a blank shell.
+  }
+}
+
+function useRefreshAuthSessionOnActive(): void {
+  useEffect(() => {
+    const subscription = AppState.addEventListener('change', (nextState) => {
+      if (nextState === 'active') {
+        void refreshAuthSessionIfNeeded(authAdapter).catch(() => undefined);
+      }
+    });
+    return () => subscription.remove();
+  }, []);
+}
+
+function resolveAuthNavigationState(
+  ready: boolean,
+  authenticated: boolean,
+): GeneratedAuthNavigationState {
+  if (!isGeneratedAuthEnforced()) return 'authenticated';
+  if (!ready) return 'pending';
+  return authenticated ? 'authenticated' : 'unauthenticated';
+}
+
+interface AuthRouteGuardInput {
+  authenticated: boolean;
+  isAuthRuntimeReady: boolean;
+  isInnerContentReady: boolean;
+  isRouteGuardDisabled?: (pathname: string) => boolean;
+  pathname: string;
+  rootNavigationKey: string;
+  router: ReturnType<typeof useRouter>;
+}
+
+function useAuthRouteGuard(args: AuthRouteGuardInput): void {
+  const { router } = args;
+  const target = resolveAuthRouteGuardTarget(args);
+  useEffect(() => {
+    if (target) router.replace(target);
+  }, [router, target]);
+}
+
+function resolveAuthRouteGuardTarget(args: AuthRouteGuardInput): Href | null {
+  if (
+    !args.isInnerContentReady ||
+    !args.isAuthRuntimeReady ||
+    args.rootNavigationKey.length === 0
+  ) {
+    return null;
+  }
+  if (args.isRouteGuardDisabled?.(args.pathname) || !isGeneratedAuthEnforced()) return null;
+
+  const activeTopLevelRoute = getTopLevelRoute(args.pathname);
+  const currentPath = normalizeRoutePath(args.pathname);
+  const postSignInPath = normalizeRoutePath(AUTH_POST_SIGN_IN_ROUTE_PATH);
+  if (!args.authenticated) {
+    return !AUTH_PUBLIC_ROUTES.includes(activeTopLevelRoute) &&
+      currentPath !== normalizeRoutePath(AUTH_SIGN_IN_ROUTE_PATH)
+      ? AUTH_SIGN_IN_ROUTE_TARGET
+      : null;
+  }
+  if (currentPath === '/' && postSignInPath !== '/') return AUTH_POST_SIGN_IN_ROUTE_TARGET;
+  const isAuthEntry =
+    activeTopLevelRoute === AUTH_SIGN_IN_ROUTE_SEGMENT ||
+    activeTopLevelRoute === AUTH_SIGN_UP_ROUTE_SEGMENT;
+  return isAuthEntry && currentPath !== postSignInPath ? AUTH_POST_SIGN_IN_ROUTE_TARGET : null;
+}
+
+function isGeneratedAuthEnforced(): boolean {
+  return !__DEV__ || !AUTH_DISABLE_IN_DEV;
+}
+
+function isAuthRoute(pathname: string): boolean {
+  const activeTopLevelRoute = getTopLevelRoute(pathname);
+  return (
+    activeTopLevelRoute === AUTH_SIGN_IN_ROUTE_SEGMENT ||
+    activeTopLevelRoute === AUTH_SIGN_UP_ROUTE_SEGMENT
+  );
+}
+
+function normalizeRoutePath(pathname: string): string {
+  const normalized = pathname.replace(/\\\/+$/, '');
+  return normalized === '' ? '/' : normalized;
+}
+
+function getTopLevelRoute(pathname: string): string {
+  const normalized = normalizeRoutePath(pathname);
+  if (normalized === '/') return 'index';
+  const [, topLevelRoute = 'index'] = normalized.split('/');
+  return topLevelRoute;
+}
+
+function getRootNavigationKey(state: { key?: string } | null | undefined): string {
+  return state?.key ?? '';
+}
+`;
+}
+//# sourceMappingURL=navigation.js.map

package/dist/host/layout/templates/auth/navigation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"navigation.js","sourceRoot":"","sources":["../../../../../src/host/layout/templates/auth/navigation.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,MAAM,iCAAiC,CAAC;AACtE,OAAO,EAAE,sBAAsB,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAU1E,SAAS,2BAA2B,CAAC,MAAyB;IAC5D,OAAO,IAAI,MAAM,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,IAAI,mBAAmB,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC;AACpF,CAAC;AAED,MAAM,UAAU,mBAAmB,CAAC,IAA6B;IAC/D,OAAO;;;;;;;;;;;;;sCAa6B,mBAAmB,CAAC,IAAI,CAAC,eAAe,CAAC;sCACzC,mBAAmB,CAAC,IAAI,CAAC,eAAe,CAAC;mCAC5C,mBAAmB,CAAC,eAAe,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;2CAC9C,mBAAmB,CAAC,sBAAsB,CAAC,IAAI,CAAC,WAAW,EAAE,MAAM,CAAC,CAAC;wCACxE,mBAAmB,CAAC,eAAe,CAAC,IAAI,CAAC,eAAe,CAAC,CAAC;gDAClD,mBAAmB,CAAC,sBAAsB,CAAC,IAAI,CAAC,eAAe,EAAE,KAAK,CAAC,CAAC;6BAC3F,2BAA2B,CAAC,IAAI,CAAC,YAAY,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2J1E,CAAC;AACF,CAAC"}

package/dist/host/layout/templates/auth/oauth.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"oauth.d.ts","sourceRoot":"","sources":["../../../../../src/host/layout/templates/auth/oauth.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,kCAAkC,CAAC;AAEnF,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,kCAAkC,CAAC;AAG5E,UAAU,4BAA6B,SAAQ,mBAAmB;IAChE,QAAQ,CAAC,aAAa,EAAE,0BAA0B,CAAC;CACpD;AAED,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,4BAA4B,UAsZvE"}
+{"version":3,"file":"oauth.d.ts","sourceRoot":"","sources":["../../../../../src/host/layout/templates/auth/oauth.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,kCAAkC,CAAC;AAEnF,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,kCAAkC,CAAC;AAG5E,UAAU,4BAA6B,SAAQ,mBAAmB;IAChE,QAAQ,CAAC,aAAa,EAAE,0BAA0B,CAAC;CACpD;AAED,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,4BAA4B,UA4SvE"}