SagnikPradhan

import { Dispatch, useReducer } from "react"
import * as z from "zod"

/**
 * useForm hook
 */
export function useForm<
  F extends string,
  A, 
  B extends z.ZodTypeDef,

SagnikPradhan

import React, { useReducer, useState } from "react"
import styled from "styled-components"
import { addMonths, getDaysInMonth, startOfMonth, getDay, endOfMonth, addDays, isEqual } from "date-fns"

const WEEK_DAYS = [ "S", "M", "T", "W", "T", "F", "S" ] as const

const CalendarCard = styled.div`
  display: flex;
  flex-direction: column;

SagnikPradhan

{
  "$schema": "https://json.schemastore.org/eslintrc",

  "env": {
    "browser": true,
    "es2021": true,
    "node": true
  },

  "extends": [

SagnikPradhan

export class AppError extends Error {
  public readonly name: string;
  public readonly isOperational: boolean;
  public readonly cause?: Error;
  public readonly additionalProps: { [additionalProps: string]: unknown };

  constructor({
    name,
    message,
    isOperational,

SagnikPradhan

import { blue, green, red, yellow } from "colorette";
import { relative } from "path";

// @ts-expect-error
import stringify from "string.ify";

interface IObject<V> {
  [K: string]: V;
}

SagnikPradhan

import fs from "fs";
import path from "path";
import { SourceMapConsumer } from "source-map";

type Nullable<T> = T | null;

export interface ParsedCallSite {
  fileName: Nullable<string>;
  line: Nullable<number>;
  column: Nullable<number>;

SagnikPradhan

import discord from 'eris'
import { Module, Server } from '../../server'

export interface DiscordEvents {
	clientConnected: []
}

interface DiscordModuleInjected {
	startClient: () => Promise<void>
}

SagnikPradhan

class F {
  f = "I am F"
}

class A extends F { a = "I am a" }
class B extends F { b = "I am b" }
class C extends F { c = "I am c" }

interface Something<T extends { [i: string]: F } = {}> {
  register: <K extends string, C extends F>(name: K, classInstance: C) => Something<T & { [key in K]: C }>

SagnikPradhan

export type Fn<Input = any, Output = any> = (input: Input) => Output;

export type Chain<Fns extends Fn[]> =
  // We chain two functions at one time
  Fns extends [infer Fn1, infer Fn2, ...infer RestFns]
    ? // Make sure two elements are functions
      Fn1 extends Fn<infer Fn1Argument>
      ? Fn2 extends Fn<infer Fn2Argument>
        ? RestFns extends Fn[]
          ? // Rest of the elements exist

SagnikPradhan

import "dotenv/config";

import { Command } from "commander";
import React from "react";
import { render } from "ink";

import { addOptions } from "./helpers/cli/options";
import { PushCommand } from "./commands/push";

const program = new Command();