guiseek

type Concrete<T> = new (...params: any[]) => T;
type Abstract<T> = abstract new (...params: any[]) => T;

type Factory<T> = (...params: any[]) => T;
type AsyncFactory<T> = (...params: any[]) => Promise<T>;

type Ref<T> = Concrete<T> | Abstract<T>;

type Use<T> = Concrete<T>;

guiseek

export type Abstract<T, P extends unknown[] = never[]> = abstract new (
  ...args: P
) => T;

guiseek

import { Abstract, AsyncFactory, Constructor, Factory, Params } from './types';
import { validate } from './validate';
import { Token } from './token';

type Ref<T> = Token<T> | Abstract<T> | Constructor<T>;

type Use<T> = Constructor<T> | Factory<T> | AsyncFactory<T> | T;

interface Config<T> {
  ref: Ref<T>;

guiseek

import { createWriteStream, PathLike } from "node:fs";
import { Console } from "node:console";

export const logger = <T>(path: PathLike, data: T[]) => {
  const stream = createWriteStream(path);

  const console = new Console(stream);

  console.table(data);

guiseek

export type Abstract<T = any> = abstract new (...params: any[]) => T;

guiseek

import {Abstract} from './abstract'
import {Type} from './type'

export type AbstractConstructorParams<T extends Type> =
  ConstructorParameters<T> extends {
    length: 1
  }
    ? [Abstract<ConstructorParameters<T>[0]>]
    : ConstructorParameters<T> extends {length: 2}
    ? [

guiseek

import {Callback} from './callback'

export class Action<T> {
  constructor(public type: string, public value: T) {}
}

export const createAction = <T>(type: string) => {
  return class extends Action<T> {
    constructor(value: T) {
      super(type, value)

guiseek

interface Callback<T> {
  (value: T): void;
}

function merge<T>(form: HTMLFormElement) {
  const watchers = new Set<Callback<T>>();
  const fields = Array.from(form.elements) as HTMLInputElement[];

  const value = <T>(form: HTMLFormElement) => {
    const data = new FormData(form);

guiseek

Table of Contents

1. Table of Contents
2. General Usage
3. File Spacing
4. Numbering and Calculations
5. Conversion and Substitution
6. Selective Printing
7. Selective Deletion

guiseek

type Tag = `${string}-${string}`;

type TagMap = HTMLElementTagNameMap;

interface CustomElement<T> extends CustomElementConstructor {
  new (...params: any[]): T;
}

function define<S extends Tag, K extends keyof TagMap>(selector: S, is?: K) {
  return (target: CustomElement<TagMap[K]>) => {