Strict types for templates

[Atulin]

Typescript types are bonkers insane, so we could go as far as validate the templates. For example, showing error on '{DD}-{xx}' saying, that xx is not valid here.

Sample code with (lots of) comments on TS playground

Shortened code without comments:

type Foo = 'a' | 'b' | 'c';

type ReplaceWithFoo<T extends string> = T extends `${infer P}[string]${infer Rest}`
  ? `${P}[${Foo}]${ReplaceWithFoo<Rest>}`
  : T;

type InferTemplateFromActual_Strict<S extends string> =
  S extends ""
    ? ""
    : S extends `${infer P}[${Foo}]${infer Rest}`
      ? InferTemplateFromActual_Strict<Rest> extends infer R
        ? R extends string
          ? `${P}[string]${R}`
          : never
        : never
      : S extends `${string}[${string}]${string}`
        ? never
        : S;

declare function fn<
  S extends string,
  T extends string = InferTemplateFromActual_Strict<S>
>(
  str: S extends ReplaceWithFoo<T> ? S : never
): T;

// Valid calls:
const template1 = fn("path/to/[a]/file");
const template2 = fn("prefix-[b]-middle-[c]");
const template3 = fn("no_placeholders");
const template4 = fn("[a]-[b]");
const template5 = fn("");

// Invalid calls (should now correctly produce type errors):
const invalid1 = fn("path/to/[string]/file");
const invalid2 = fn("path/to/[d]/file");
const invalid3 = fn("prefix-[a]-[d]");

[Atulin]

Waaaay shorter code

type Foo = 'a' | 'b' | 'c'

type IsValid<T> = T extends `${string}[${infer F}]${infer T}`
    ? F extends Foo
        ? IsValid<T>
        : false
    : true

declare function fn<T extends string>(
    str: IsValid<T> extends true ? T : never,
): T

[Atulin]

With error message

type Foo = 'a' | 'b' | 'c'

type OnlyAllow<T extends string, AllowedValues extends string> =
    ComputeValues<T> extends AllowedValues ? T :
    {_error: ["These values are not allowed:", Exclude<ComputeValues<T>, AllowedValues>]}
;

type ComputeValues<T extends string> =
    T extends `${string}[${infer Val}]${infer Rest}` ? Val | ComputeValues<Rest> : never;

declare function fn<T extends string>(str: OnlyAllow<T, Foo>): T;