@atproto/oauth-provider-ui 0.1.0 → 0.1.2

package/src/hooks/use-stepper.ts

@@ -1,87 +0,0 @@
-import { useCallback, useEffect, useState } from 'react'
-
-export type DisabledStep = false | null | undefined
-export type Step = {
-  invalid: boolean
-}
-
-const isEnabled = <S extends Step | DisabledStep>(
-  s: S,
-): s is S extends DisabledStep ? never : S => s != null && s !== false
-const isRequired = <S extends Step | DisabledStep>(
-  s: S,
-): s is S extends DisabledStep ? never : S & { invalid: true } =>
-  isEnabled(s) && s.invalid === true
-const isCompleted = <S extends Step | DisabledStep>(
-  s: S,
-): s is S extends DisabledStep ? S : S & { invalid: false } =>
-  !isEnabled(s) || s.invalid === false
-
-export function useStepper<const S extends Step>(
-  steps: readonly (S | DisabledStep)[],
-) {
-  const firstIdx = steps.findIndex(isEnabled)
-  const lastIdx = steps.findLastIndex(isEnabled)
-  const requiredIdx = steps.findIndex(isRequired)
-
-  const [currentIdx, setCurrentIdx] = useState<number>(firstIdx)
-
-  const to = useCallback(
-    (idx: number) => {
-      if (idx !== -1 && steps[idx]) {
-        setCurrentIdx(idx)
-        return true
-      } else {
-        return false
-      }
-    },
-    [steps.map(isEnabled).join()],
-  )
-
-  const prevIdx = steps.findLastIndex((s, i) => isEnabled(s) && i < currentIdx)
-  const nextIdx = steps.findIndex((s, i) => isEnabled(s) && i > currentIdx)
-
-  const toFirst = useCallback(() => to(firstIdx), [to, firstIdx])
-  const toLast = useCallback(() => to(lastIdx), [to, lastIdx])
-  const toPrev = useCallback(() => to(prevIdx), [to, prevIdx])
-  const toNext = useCallback(() => to(nextIdx), [to, nextIdx])
-  const toRequired = useCallback(() => to(requiredIdx), [to, requiredIdx])
-
-  // Step number in user friendly terms (accounting for disabled steps)
-  const currentPosition =
-    currentIdx +
-    // use "1 indexed position" (for user friendliness):
-    1 +
-    // Adjust the position by counting the number of disabled steps before the
-    // current step (if any):
-    steps.reduce(
-      (acc, s, i) => (i >= currentIdx || isEnabled(s) ? acc : acc - 1),
-      0,
-    )
-
-  const count = steps.filter(isEnabled).length
-  const completed = steps.every(isCompleted)
-
-  const current =
-    currentIdx === -1 || !steps[currentIdx] ? undefined : steps[currentIdx]
-
-  // Fool-proof (reset current step in case the current step becomes disabled)
-  const broken = currentIdx === -1
-  useEffect(() => {
-    if (broken) toFirst()
-  }, [broken])
-
-  return {
-    current,
-    currentPosition,
-    count,
-    completed,
-    atFirst: currentPosition === 1,
-    atLast: currentPosition === count,
-    toFirst,
-    toLast,
-    toPrev,
-    toNext,
-    toRequired,
-  }
-}

package/src/lib/api.ts

@@ -1,225 +0,0 @@
-import {
-  API_ENDPOINT_PREFIX,
-  ApiEndpoints,
-  CSRF_COOKIE_NAME,
-  CSRF_HEADER_NAME,
-} from '@atproto/oauth-provider-api'
-import { readCookie } from './cookies.ts'
-import {
-  JsonClient,
-  JsonErrorPayload,
-  JsonErrorResponse,
-} from './json-client.ts'
-
-export type { Options } from './json-client.ts'
-
-export class Api extends JsonClient<ApiEndpoints> {
-  constructor() {
-    const baseUrl = new URL(API_ENDPOINT_PREFIX, window.origin).toString()
-    super(baseUrl, () => ({
-      [CSRF_HEADER_NAME]: readCookie(CSRF_COOKIE_NAME),
-    }))
-  }
-
-  // Override the parent's parseError method to handle expected error responses
-  // and transform them into instances of the corresponding error classes.
-  public static override parseError(
-    json: unknown,
-  ): undefined | JsonErrorResponse {
-    // @NOTE Most specific errors first !
-    if (SecondAuthenticationFactorRequiredError.is(json)) {
-      return new SecondAuthenticationFactorRequiredError(json)
-    }
-    if (InvalidCredentialsError.is(json)) {
-      return new InvalidCredentialsError(json)
-    }
-    if (InvalidInviteCodeError.is(json)) {
-      return new InvalidInviteCodeError(json)
-    }
-    if (HandleUnavailableError.is(json)) {
-      return new HandleUnavailableError(json)
-    }
-    if (EmailTakenError.is(json)) {
-      return new EmailTakenError(json)
-    }
-    if (RequestExpiredError.is(json)) {
-      return new RequestExpiredError(json)
-    }
-    if (UnknownRequestUriError.is(json)) {
-      return new UnknownRequestUriError(json)
-    }
-    if (InvalidRequestError.is(json)) {
-      return new InvalidRequestError(json)
-    }
-    if (AccessDeniedError.is(json)) {
-      return new AccessDeniedError(json)
-    }
-    return super.parseError(json)
-  }
-}
-
-export type AccessDeniedPayload = JsonErrorPayload<'access_denied'>
-export class AccessDeniedError<
-  P extends AccessDeniedPayload = AccessDeniedPayload,
-> extends JsonErrorResponse<P> {
-  constructor(
-    payload: P,
-    message = payload.error_description || 'Access denied',
-  ) {
-    super(payload, message)
-  }
-
-  static is(json: unknown): json is AccessDeniedPayload {
-    return super.is(json) && json.error === 'access_denied'
-  }
-}
-
-export type InvalidRequestPayload = JsonErrorPayload<'invalid_request'>
-export class InvalidRequestError<
-  P extends InvalidRequestPayload = InvalidRequestPayload,
-> extends JsonErrorResponse<P> {
-  constructor(
-    payload: P,
-    message = payload.error_description || 'Invalid request',
-  ) {
-    super(payload, message)
-  }
-
-  static is(json: unknown): json is InvalidRequestPayload {
-    return super.is(json) && json.error === 'invalid_request'
-  }
-}
-
-export type InvalidInviteCodePayload = InvalidRequestPayload & {
-  error_description: `This invite code is invalid.${string}`
-}
-export class InvalidInviteCodeError<
-  P extends InvalidInviteCodePayload = InvalidInviteCodePayload,
-> extends InvalidRequestError<P> {
-  constructor(payload: P) {
-    super(payload)
-  }
-
-  static is(json: unknown): json is InvalidInviteCodePayload {
-    return (
-      super.is(json) &&
-      json.error_description != null &&
-      json.error_description.startsWith('This invite code is invalid.')
-    )
-  }
-}
-
-export type RequestExpiredPayload = AccessDeniedPayload & {
-  error_description: 'This request has expired'
-}
-export class RequestExpiredError<
-  P extends RequestExpiredPayload = RequestExpiredPayload,
-> extends AccessDeniedError<P> {
-  static is(json: unknown): json is RequestExpiredPayload {
-    return (
-      super.is(json) && json.error_description === 'This request has expired'
-    )
-  }
-}
-
-export type InvalidCredentialsPayload = InvalidRequestPayload & {
-  error_description: 'Invalid identifier or password'
-}
-export class InvalidCredentialsError<
-  P extends InvalidCredentialsPayload = InvalidCredentialsPayload,
-> extends InvalidRequestError<P> {
-  static is(json: unknown): json is InvalidCredentialsPayload {
-    return (
-      super.is(json) &&
-      json.error_description === 'Invalid identifier or password'
-    )
-  }
-}
-
-export type UnknownRequestPayload = InvalidRequestPayload & {
-  error_description: 'Unknown request_uri'
-}
-export class UnknownRequestUriError<
-  P extends UnknownRequestPayload = UnknownRequestPayload,
-> extends InvalidRequestError<P> {
-  static is(json: unknown): json is UnknownRequestPayload {
-    return super.is(json) && json.error_description === 'Unknown request_uri'
-  }
-}
-export type EmailTakenPayload = InvalidRequestPayload & {
-  error_description: 'Email already taken'
-}
-export class EmailTakenError<
-  P extends EmailTakenPayload = EmailTakenPayload,
-> extends InvalidRequestError<P> {
-  static is(json: unknown): json is EmailTakenPayload {
-    return super.is(json) && json.error_description === 'Email already taken'
-  }
-}
-
-export type HandleUnavailablePayload =
-  JsonErrorPayload<'handle_unavailable'> & {
-    reason: 'syntax' | 'domain' | 'slur' | 'taken'
-  }
-export class HandleUnavailableError<
-  P extends HandleUnavailablePayload = HandleUnavailablePayload,
-> extends JsonErrorResponse<P> {
-  constructor(
-    payload: P,
-    message = payload.error_description || 'That handle cannot be used',
-  ) {
-    super(payload, message)
-  }
-
-  get reason() {
-    return this.payload.reason
-  }
-
-  static is(json: unknown): json is HandleUnavailablePayload {
-    return (
-      super.is(json) &&
-      json.error === 'handle_unavailable' &&
-      'reason' in json &&
-      (json.reason === 'syntax' ||
-        json.reason === 'domain' ||
-        json.reason === 'slur' ||
-        json.reason === 'taken')
-    )
-  }
-}
-
-export type SecondAuthenticationFactorRequiredPayload =
-  JsonErrorPayload<'second_authentication_factor_required'> & {
-    type: 'emailOtp'
-    hint: string
-  }
-export class SecondAuthenticationFactorRequiredError<
-  P extends
-    SecondAuthenticationFactorRequiredPayload = SecondAuthenticationFactorRequiredPayload,
-> extends JsonErrorResponse<P> {
-  constructor(
-    payload: P,
-    message = payload.error_description ||
-      `${payload.type} authentication factor required (hint: ${payload.hint})`,
-  ) {
-    super(payload, message)
-  }
-
-  get type() {
-    return this.payload.type
-  }
-  get hint() {
-    return this.payload.hint
-  }
-
-  static is(json: unknown): json is SecondAuthenticationFactorRequiredPayload {
-    return (
-      super.is(json) &&
-      json.error === 'second_authentication_factor_required' &&
-      'type' in json &&
-      json.type === 'emailOtp' &&
-      'hint' in json &&
-      typeof json.hint === 'string'
-    )
-  }
-}

package/src/lib/cookies.ts

@@ -1,17 +0,0 @@
-export const parseCookieString = (
-  cookie: string = document.cookie,
-): Record<string, string | undefined> =>
-  Object.fromEntries(
-    cookie
-      .split(';')
-      .filter(Boolean)
-      .map((str) => str.split('=', 2).map((s) => decodeURIComponent(s.trim()))),
-  )
-
-export function readCookie(
-  name: string,
-  cookie: string = document.cookie,
-): string | undefined {
-  const cookies = parseCookieString(cookie)
-  return cookies[name]
-}

package/src/lib/json-client.ts

@@ -1,141 +0,0 @@
-// Using a type import to avoid bundling this lib
-import type { Json } from '@atproto-labs/fetch'
-
-export { type Json }
-type Awaitable<T> = T | PromiseLike<T>
-
-export type Options = {
-  signal?: AbortSignal
-  bearer?: string
-}
-
-export type EndpointPath = `/${string}`
-export type EndpointDefinition =
-  | {
-      method: 'POST'
-      input: Json
-      output: Json | void
-    }
-  | {
-      method: 'GET'
-      params?: Record<string, string | undefined>
-      output: Json | void
-    }
-
-export class JsonClient<
-  Endpoints extends { [Path: EndpointPath]: EndpointDefinition },
-> {
-  constructor(
-    protected readonly baseUrl: string,
-    protected readonly getHeaders: () => Awaitable<
-      Record<string, string | undefined>
-    >,
-  ) {}
-
-  public async fetch<Path extends EndpointPath & keyof Endpoints>(
-    method: Endpoints[Path]['method'],
-    path: Path,
-    input: Endpoints[Path] extends { method: 'GET' }
-      ? Endpoints[Path]['params']
-      : Endpoints[Path] extends { method: 'POST' }
-        ? Endpoints[Path]['input']
-        : undefined,
-    options?: Options,
-  ): Promise<Endpoints[Path]['output']> {
-    const url = new URL(`${this.baseUrl}${path}`)
-    if (method === 'GET') {
-      if (input) {
-        for (const [key, value] of Object.entries(input)) {
-          url.searchParams.set(key, value)
-        }
-      }
-    }
-
-    const body = method === 'POST' ? JSON.stringify(input) : undefined
-
-    const headers = Object.entries(await this.getHeaders.call(null))
-      .filter((entry): entry is [string, string] => entry[1] != null)
-      .map(([k, v]) => [k.toLowerCase(), v] as [string, string])
-
-    if (options?.bearer) {
-      headers.push(['authorization', `Bearer ${options.bearer}`])
-    }
-
-    const response = await fetch(url, {
-      method,
-      headers:
-        body && !headers.some(([k]) => k === 'content-type')
-          ? headers.concat([['content-type', 'application/json']])
-          : headers,
-      mode: 'same-origin',
-      body,
-      signal: options?.signal,
-    })
-
-    if (response.status === 204) {
-      return undefined
-    }
-
-    const responseType = response.headers.get('content-type')
-    if (responseType !== 'application/json') {
-      await response.body?.cancel()
-      throw new Error(`Invalid content type "${responseType}"`, {
-        cause: response,
-      })
-    }
-
-    const json = await response.json()
-
-    if (response.ok) return json as Endpoints[Path]['output']
-    else throw this.parseError(response, json)
-  }
-
-  protected parseError(response: Response, json: Json): Error {
-    const Class = this.constructor as typeof JsonClient
-    const error = Class.parseError(json)
-    if (error) return error
-
-    return new Error('Invalid JSON response', { cause: response })
-  }
-
-  public static parseError(json: unknown): undefined | JsonErrorResponse {
-    if (JsonErrorResponse.is(json)) {
-      return new JsonErrorResponse(json)
-    }
-  }
-}
-
-export type JsonErrorPayload<E extends string = string> = {
-  error: E
-  error_description?: string
-}
-
-export class JsonErrorResponse<
-  P extends JsonErrorPayload = JsonErrorPayload,
-> extends Error {
-  constructor(
-    public readonly payload: P,
-    message = payload.error_description,
-    options?: ErrorOptions,
-  ) {
-    super(message || `Error "${payload.error}"`, options)
-  }
-
-  get error(): string {
-    return this.payload.error
-  }
-
-  get description(): string | undefined {
-    return this.payload.error_description
-  }
-
-  static is(json: unknown): json is JsonErrorPayload {
-    return (
-      json != null &&
-      typeof json === 'object' &&
-      typeof json['error'] === 'string' &&
-      (json['error_description'] === undefined ||
-        typeof json['error_description'] === 'string')
-    )
-  }
-}

package/src/lib/password.ts

@@ -1,98 +0,0 @@
-export const MIN_PASSWORD_LENGTH = 8
-
-const EMOJI =
-  /(\ud83c[\ud000-\udfff]|\ud83d[\ud000-\udfff]|\ud83e[\ud000-\udfff])/
-const UPPER = /[A-Z]/
-const LOWER = /[a-z]/
-const DEC = /[0-9]/
-const SPECIAL = /[^a-zA-Z0-9]/
-
-export enum PasswordStrength {
-  weak = 1,
-  moderate = 2,
-  strong = 3,
-  extra = 4,
-}
-
-export function getPasswordStrength(pwd: string): PasswordStrength {
-  if (pwd.length < MIN_PASSWORD_LENGTH) {
-    return PasswordStrength.weak
-  }
-
-  // Very long passwords
-  if (pwd.length >= MIN_PASSWORD_LENGTH + 12) {
-    return PasswordStrength.extra
-  }
-
-  // Long passwords
-  if (pwd.length >= MIN_PASSWORD_LENGTH + 8) {
-    if (matches(pwd, [SPECIAL])) {
-      return PasswordStrength.extra
-    }
-    if (matches(pwd, [UPPER, LOWER, DEC], 2)) {
-      return PasswordStrength.extra
-    }
-    return PasswordStrength.strong
-  }
-
-  // Emojis make passwords strong
-  if (pwd.length >= MIN_PASSWORD_LENGTH) {
-    if (matches(pwd, [EMOJI])) {
-      return PasswordStrength.strong
-    }
-  }
-
-  // Pretty long passwords
-  if (pwd.length >= MIN_PASSWORD_LENGTH + 6) {
-    if (matches(pwd, [SPECIAL])) {
-      return PasswordStrength.strong
-    }
-    if (matches(pwd, [UPPER, LOWER, DEC], 2)) {
-      return PasswordStrength.strong
-    }
-    // Only 1 type of alpha-num characters
-    return PasswordStrength.moderate
-  }
-
-  // Longish password
-  if (pwd.length >= MIN_PASSWORD_LENGTH + 4) {
-    if (matches(pwd, [SPECIAL])) {
-      return PasswordStrength.moderate
-    }
-    if (matches(pwd, [UPPER, LOWER, DEC], 2)) {
-      return PasswordStrength.moderate
-    }
-
-    // Only 1 type of alpha-num characters
-    return PasswordStrength.weak
-  }
-
-  // Short password (8-11 characters)
-  if (pwd.length >= MIN_PASSWORD_LENGTH) {
-    if (matches(pwd, [SPECIAL])) {
-      return PasswordStrength.moderate
-    }
-    if (matches(pwd, [UPPER, LOWER, DEC])) {
-      return PasswordStrength.moderate
-    }
-  }
-
-  return PasswordStrength.weak
-}
-
-function matches(
-  pwd: string,
-  regexps: RegExp[],
-  regexpsCountToMatch: number = regexps.length,
-): boolean {
-  if (regexpsCountToMatch < 1 || regexpsCountToMatch > regexps.length) {
-    throw new TypeError('Invalid regexpsCountToMatch')
-  }
-  for (const regexp of regexps) {
-    if (regexp.test(pwd)) {
-      regexpsCountToMatch--
-      if (regexpsCountToMatch === 0) return true
-    }
-  }
-  return false
-}

package/src/lib/ref.ts

@@ -1,17 +0,0 @@
-import { ForwardedRef } from 'react'
-
-export function updateRef<T>(ref: ForwardedRef<T>, value: T | null) {
-  if (typeof ref === 'function') {
-    ref(value)
-  } else if (ref) {
-    ref.current = value
-  }
-}
-
-export function mergeRefs<T>(refs: readonly (ForwardedRef<T> | undefined)[]) {
-  return (value: T | null) => {
-    for (const ref of refs) {
-      if (ref) updateRef(ref, value)
-    }
-  }
-}

package/src/lib/util.ts

@@ -1,14 +0,0 @@
-export function upsert<T>(
-  arr: undefined | readonly T[],
-  item: T,
-  predicate: (value: T, index: number, obj: readonly T[]) => boolean,
-): T[] {
-  if (!arr) return [item]
-  const idx = arr.findIndex(predicate)
-  return idx === -1
-    ? [...arr, item]
-    : [...arr.slice(0, idx), item, ...arr.slice(idx + 1)]
-}
-
-export type Simplify<T> = { [K in keyof T]: T[K] } & NonNullable<unknown>
-export type Override<T, U> = Simplify<Omit<T, keyof U> & U>