697 - Tag

[ianbunag]

Try me!

Expectation changes

"Has tags" predicate assertion changed to be non positional

Current assertions will only pass if tags argument order matches tagging order

type Cases = [
  // Should only pass if tags arguments is ["bar", "foo"]
  Expect<Equal<HasTags<Tag<Tag<{}, "bar">, "foo">, ["foo", "bar"]>, false>>,
  // Should only pass if tags arguments is ["foo", "baz"] or ["foo", "baz", 'bar]
  Expect<Equal<HasTags<Tag<Tag<Tag<{}, "foo">, "baz">, "bar">, ["foo", "bar"]>, false>>,
]

Solution will only fail if a non existent tag is provided

type Cases = [
  // Will pass for ["foo", "bar", "baz"], ["baz", "bar", "foo"], ...etc
  Expect<Equal<HasTags<Tag<Tag<Tag<{}, "foo">, "baz">, "bar">, ["foo", "bar"]>, true>>,
]

Solution

type Flatten<Type> = { [Key in keyof Type]: Type[Key] }

type UnionToIntersection<Type> = (
  Type extends any ? (wrapper: Type) => unknown :never
) extends (wrapper: infer WrappedType) => unknown ? WrappedType : never

type UnionToTuple<Type> = UnionToIntersection<
  Type extends any ? (wrapper: Type) => unknown :never
> extends (wrapper: infer WrappedType) => unknown
  ? [...UnionToTuple<Exclude<Type, WrappedType>> ,WrappedType]
  : []

/**
 * Copy of:
 *  import { Equal } from "@type-challenges/utils";
 */
type Equivalent<X, Y> =
  (<T>() => T extends X ? 1 : 2) extends
  (<T>() => T extends Y ? 1 : 2) ? true : false

declare const TagKey: unique symbol;

type Injectable<Target> = typeof TagKey extends keyof Target
  ? Omit<Target, never> // Preserve special types like any, unknown and never
  : Target

type InjectTag<Target, Type = {}> = Injectable<Target> & { [TagKey]?: Type }

type Tag<
  Target,
  Type extends string
> = Equivalent<Target, null> extends true
  ? null
  : Equivalent<Target, undefined> extends true
    ? undefined
    : Injectable<Target> extends Injectable<InjectTag<infer RootTarget, infer RootType>>
      ? InjectTag<
          RootTarget,
          Flatten<
            { [Key in keyof RootType]?: RootType[Key]} &
            { [Key in Type]?: Type } &
            Record<string, string>
          >
        >
      : InjectTag<
          Target,
          Flatten<
            { [Key in Type]?: Type } &
            Record<string, string>
          >
        >

type GetTagUnion<
  Target
> = Target extends InjectTag<unknown, infer Tags>
  ? keyof { [Key in keyof Tags as string extends Key ? never : Key]: Tags[Key] }
  : never

type GetCommonTagUnion<
  Target,
  TargetTuple = UnionToTuple<Target>
> = TargetTuple extends [infer CurrentTarget, ...infer RestTarget]
  ? RestTarget extends []
    ? GetTagUnion<CurrentTarget>
    : GetTagUnion<CurrentTarget> & GetCommonTagUnion<RestTarget[number]>
  : never

type GetTags<Target> = UnionToTuple<GetCommonTagUnion<Target>>

type UnTag<Target> = keyof Target extends never
  ? Target
  : Omit<Target, typeof TagKey>

type HasTag<
  Target,
  Type extends string
> = Type extends GetCommonTagUnion<Target>
  ? true
  : false

type HasTags<
  Target,
  Type extends ReadonlyArray<string>
> = Type[number] extends GetCommonTagUnion<Target>
  ? true
  : false

type HasExactTags<
  Target,
  Type extends ReadonlyArray<string>
> = GetCommonTagUnion<Target> extends Type[number]
  ? true
  : false