@gershy/clearing 0.0.2 → 0.0.3

package/src/global.d.ts

@@ -1,197 +0,0 @@
-// Util
-type fn = (...args: any[]) => any;
-type obj = { [key: string]: any };
-type maybeFn<T> = T | ((...args: any[]) => T);
-type maybeFnResolved<T> = T extends (...args: any[]) => any ?  ReturnType<T> : T;
-type MaybePromise<T> = T | Promise<T>;
-
-// Forms
-type formConfig = {
-  name: string,
-  has: { [key: string]: any },
-  props: { [key: string]: any }
-};
-type Form<props extends {}, initArgs extends any[], state extends {}> = {
-  '~props': maybeFnResolved<props>,
-  '~initArgs': initArgs,
-  '~state': state,
-  (...a: initArgs): formInstance<Form<props, initArgs, state>>,
-  new (...a: initArgs): formInstance<Form<props, initArgs, state>>
-};
-type formInstance<MyForm extends Form> = { '~form': MyForm }
-  & { [ key in keyof MyForm['~props'] ]: MyForm['~props'][key] }
-  & { [ key in keyof MyForm['~state'] ]: MyForm['~state'][key] };
-
-// Globals
-declare const global: any;
-declare const window: any;
-declare const getFormName: (f: any) => string;
-declare const denumerate: (val: any, name: string) => void;
-declare const skip: never;
-declare const isForm: {
-  (val: any, arr: FunctionConstructor): val is fn;
-  (val: any, obj: ObjectConstructor): val is { [key: string]: any };
-  (val: any, str: StringConstructor): val is string;
-  (val: any, num: NumberConstructor): val is number;
-  (val: any, arr: ArrayConstructor): val is any[];
-  <T>(val: any, prm: PromiseConstructor): val is Promise<T>;
-  <T>(val: any, t: T): val is T;
-}
-declare const hasForm: {
-  (val: any, t: any): boolean;
-}
-declare const form: <initArgs extends any[], state extends {}>(c: formConfig) => Form<formConfig['props'], initArgs, state>;
-declare const formatAnyValue: (val: any) => string;
-declare const C: {
-  def: fn
-};
-declare const getMs: () => number;
-declare const getDate: () => string;
-declare const then: (val: any, resolve: fn, reject?: fn) => any;
-declare const valToJson: (val: any) => string;
-declare const valToSer: (val: any) => string;
-declare const jsonToVal: (val: string | Buffer | null) => any;
-declare const GeneratorFunction: any;
-declare const global: { [key: string|symbol]: any } & {
-  skip: typeof skip,
-  GeneratorFunction: typeof GeneratorFunction,
-  isForm: typeof isForm,
-  hasForm: typeof hasForm,
-  formatAnyValue: typeof formatAnyValue,
-  then: typeof then,
-  getMs: typeof getMs,
-  getDate: typeof getDate,
-  valToJson: typeof valToJson,
-  jsonToVal: typeof jsonToVal,
-  C: typeof C,
-  denumerate: typeof denumerate
-};
-
-interface JSON {
-  parse: (val: Buffer) => any
-}
-
-interface Array<T> {
-  any: (fn: fn) => boolean,
-  has: (val: T) => boolean,
-  add: (val: T) => void,
-  count: () => number,
-  valSort: (fn: (val: T) => number) => Array<T>,
-  find: (fn: fn) => ({ found: true, val: T } | { found: false }),
-  each: (fn: (val: T) => void) => void,
-  empty: () => boolean,
-  equals: <Z>(arr: Array<T>) => Z extends T ? boolean : false,
-  toObj: (fn: fn) => any,
-  seek: (fn: (val: T) => any) => { found: boolean, val: T | undefined, ind: number },
-}
-interface ArrayConstructor {
-  stub: any[]
-}
-
-interface Error {
-  mod: (props: { [key: string]: any }) => Error
-  propagate: (props?: { [key: string]: any }) => never
-}
-
-interface FunctionConstructor {
-  stub: (...args: any[]) => any
-}
-interface Function {
-  bound: fn
-}
-
-interface GeneratorFunctionConstructor {
-}
-
-interface Number {
-  encodeStr: (str: string | CharSet, len?: number) => string,
-  each: (fn: (n: number) => void) => void,
-  toArr: <T>(fn: (n: number) => T) => T[]
-}
-interface NumberConstructor {
-  int32: number
-}
-
-interface BigInt {
-  encodeStr: Number[encodeStr]
-}
-
-interface ObjectConstructor {
-}
-interface Object {
-  empty: () => boolean,
-  has: (k: string) => boolean,
-  map: (fn: (val: any, key: string) => any) => any,
-  mapk: (fn: (val: any, key: string) => [ string, any ]) => any,
-  at: (k: string | string[], def?: any) => any,
-  plain: (obj?: any) => any,
-  slice: <T>(this: T, keys: (keyof T)[]) => Partial<T>,
-  omit: <T>(this: T, keys: (keyof T)[]) => Partial<T>,
-  toArr: <T extends (v: any, k: string) => any>(fn: T) => ReturnType<T>[],
-  built: () => Object,
-  merge: <T>(val: T) => Object & T,
-  gain: (...args: any[]) => any,
-  [Symbol.iterator]: () => Iterator<[ string, any]>
-}
-
-interface Promise<T> {
-  fail: Promise<T>['catch'],
-}
-
-interface PromiseLater<T=void> extends Promise<T> {
-  resolve: T extends void ? () => void : (v: T) => void,
-  reject: (err: any) => void
-}
-interface PromiseConstructor {
-  <T>(fn: (resolve: (v: T) => void, reject: (err: any) => void) => any): Promise<T>,
-  later: <T=void>() => PromiseLater<T>,
-  all: {
-    <T>(values: Iterable<T | PromiseLike<T>>): Promise<Awaited<T>[]>;
-    
-    //<T>(arr: Promise<T>[]): Promise<T[]>,
-    //<T>(obj: { [key: string]: Promise<T> }): Promise<{ [key: string]: T }>
-  }
-}
-
-interface SetConstructor {
-  <T>(arr?: T[]): Set<T>
-}
-interface Set<T> {
-  toArr: (fn: (val: T, ind: number) => void) => T[],
-  rem: (val: T) => void
-}
-
-interface MapConstructor {
-  <K, V>(arr?: [ K, V ][]): Map<K, V>
-}
-interface Map<K, V> {
-  add: (k: K, v: V) => void,
-  toArr: <T>(fn: (val: V, key: K) => T) => T[],
-  rem: (key: K) => void
-}
-
-type CharSet = { str: string, size: bigint, charVal: (c: string) => bigint, valChar: (n: bigint) => string };
-interface String {
-  count(): number,
-  padHead(n: number, s?: string): string,
-  padTail(n: number, s?: string): string,
-  encodeInt: (chrs: string | CharSet) => bigint,
-  reencode: (src: string | CharSet, trg: string | CharSet) => string,
-  trimHead(): string,
-  trimTail(): string,
-  hasHead(head: string): boolean,
-  upper(): string,
-  lower(): string,
-  cut(str: string, cuts?: number): string[],
-  indent: {
-    (amount: number, char?: string): string,
-    (str: string): string
-  }
-}
-interface StringConstructor {
-  charset: (str: string) => CharSet,
-  base32: string,
-  base62: string,
-  baseline: (str: string) => str,
-  multiline: (str: string) => str,
-}