temoncher

// https://unicode-org.github.io/icu/userguide/format_parse/messages/
type Trim<S extends string> =
    S extends ` ${infer R}` | `${infer R} ` | `\n${infer R}` | `${infer R}\n` ? Trim<R> : S;

type AccumulateBeforeClosing<S extends string, TStack extends unknown[] = [], R extends string = ''> = S extends `${infer TBeforeClosing}}${infer TAfterClosing}`
    ? S extends `${infer TBeforeOpening}{${infer TAfterOpening}`
    ? TBeforeOpening extends `${TBeforeClosing}${string}`
    ? TStack['length'] extends 0
    ? `${R}${TBeforeClosing}`
    : TStack extends [...infer TStart, infer TLast]

temoncher

import {
  factorius,
  requires,
  instance,
  transient,
  optional,
  externalId,
  type,
  tokensOf,
} from './factorius';

temoncher

declare const errorTag: unique symbol;
type TypesError<T> = { [errorTag]: T };
interface Validatable {
    validate(): boolean;
}
type Assert<T, TType, TTypeName extends string, TTargetName extends string = string, TSource extends string = string> = T extends TType ? T :
    string extends TTargetName
    ? TypesError<`T should be of type {${TTypeName}}`>
    : string extends TSource
    ? TypesError<`{${TTargetName}} should be of type {${TTypeName}}`>

temoncher

import { type O } from 'ts-toolbelt';

type InferInterpolation<TString> =
  TString extends `${string}{${infer I}}${infer R}`
    ? O.Merge<{ [K in I]: string | number }, InferInterpolation<R>>
    : object;

type TFunctionParams<
  TNamespace,
  TKey extends keyof TNamespace,

temoncher

/* eslint-disable @typescript-eslint/no-unsafe-return */
/* eslint-disable @typescript-eslint/no-explicit-any */
import { type O } from 'ts-toolbelt';

type MapLayer<TServices> =
  TServices extends Record<string, (di: any) => any>
    ? {
        [K in keyof TServices]: ReturnType<TServices[K]>;
      }
    : never;

temoncher

import { mapValues } from 'remeda';

export class Token<in out T> {
  constructor(readonly id: string) {}
}
export declare namespace Token {
  export type Type<T extends Token<any>> = T extends Token<infer S> ? S : never;
}

export class Container<in TTokens extends Token<any> = never> {

temoncher

// TODO: make eslint rule only allowing to UseHook inside client components
// TODO: make eslint rule not allowing conditions inside useHook
export function UseHook<T>(props: {
  useHook: () => T;
  children: (hookResult: T) => JSX.Element;
}) {
  const hookResult = props.useHook();

  return <>{props.children(hookResult)}</>;
}

temoncher

class Token<T, Id extends string> {
    /** @typeonly */
    private readonly __type: T = null!;
    constructor(readonly id: Id) {}
}
declare namespace Token {
    export type Type<T> = T extends Token<infer TokenType, string> ? TokenType : never;
    export type Id<T> = T extends Token<unknown, infer TokenId> ? TokenId : never;
}

temoncher

let currentInjector: IInjector | null = null;

function runInInjectionContext(injector: IInjector, fn: () => void) {
    const prevInjector = currentInjector;
    currentInjector = injector;

    try {
        fn();
    } finally {
        currentInjector = prevInjector;

temoncher

type NeverIfNotExtends<T, P> = T extends P ? T : never;

type IFactoryBindConfig = {
    fresh: true;
    eager?: false;
} | {
    fresh: false;
    eager?: boolean;
}