Refine `isReadonlyOf` and related about unknownutil HOT 3 CLOSED

import { is, Predicate } from "./mod.ts";

function optional<K extends PropertyKey>(name: K): K {
  return name;
}

function readonly<K extends PropertyKey>(name: K): K {
  return name;
}

function annotate<T>(
  pred: Predicate<T>,
  annotations: { optional?: boolean; readonly?: boolean },
): Predicate<T> {
  return pred;
}

const as = {
  Optional: <T>(pred: Predicate<T>) => pred,
  Readonly: <T>(pred: Predicate<T>) => pred,
};

const pattern1 = is.ObjectOf({
  [optional("optionalField")]: is.String,
  [readonly("readonlyField")]: is.String,
  [readonly(optional("readonlyOptionalField"))]: is.String,
});

const pattern2 = is.ObjectOf({
  optionalField: annotate(is.String, { optional: true }),
  readonlyField: annotate(is.String, { readonly: true }),
  readonlyOptionalField: annotate(is.String, {
    optional: true,
    readonly: true,
  }),
});

const pattern3 = is.ObjectOf({
  optionalField: as.Optional(is.String),
  readonlyField: as.Readonly(is.String),
  readonlyOptionalField: as.Readonly(as.Optional(is.String)),
});

type A = {
  foo?: string;
  readonly bar: string;
  readonly hoge?: string;
};

// Predicate<A>
const a = is.ObjectOf({
  foo: as.Optional(is.String),
  bar: as.Readonly(is.String),
  hoge: as.Optional(as.Readonly(is.String)),
});

type B = Partial<A>;

// Predicate<B>
const b = is.PartialOf(a);

type C = Readonly<A>;

// Predicate<C>
const c = is.ReadonlyOf(a);