export type Schema<T> = (value: unknown) => value is T;

export const string: Schema<string> = (value) => typeof value === "string";

export const boolean: Schema<boolean> = (value) => typeof value === "boolean";

export const finiteNumber: Schema<number> = (value): value is number =>
  typeof value === "number" && Number.isFinite(value);

export const record: Schema<Record<string, unknown>> = (
  value,
): value is Record<string, unknown> =>
  typeof value === "object" && value !== null;

export const literal =
  <const T extends string>(...values: T[]): Schema<T> =>
  (value): value is T =>
    values.includes(value as T);

export const arrayOf =
  <T>(item: Schema<T>): Schema<T[]> =>
  (value): value is T[] =>
    Array.isArray(value) && value.every(item);

export const recordOf =
  <T>(item: Schema<T>): Schema<Record<string, T>> =>
  (value): value is Record<string, T> =>
    record(value) && Object.values(value).every(item);

export const nonEmpty =
  <T extends { length: number }>(schema: Schema<T>): Schema<T> =>
  (value): value is T =>
    schema(value) && value.length > 0;

export const optional =
  <T>(schema: Schema<T>): Schema<T | undefined> =>
  (value): value is T | undefined =>
    value === undefined || schema(value);

export const object =
  <T>(shape: { [K in keyof T]-?: Schema<T[K]> }): Schema<T> =>
  (value): value is T =>
    record(value) &&
    Object.entries<Schema<unknown>>(shape as never).every(([key, check]) =>
      check(value[key]),
    );