@modular-component/core 0.1.7 → 0.2.1

package/src/types/methods/mock.ts

@@ -1,90 +0,0 @@
-/**
- * Methods for mocking the value returned by a given stage,
- * replacing the stage and bypassing its transform function
- */
-
-import { ModularComponent } from '../modular-component'
-import { MethodRecord } from '../methods'
-import { ValidateIndex } from '../validation'
-import { ComputeArguments } from '../arguments'
-import { FilterNever, Last, ToIndices } from '../utils'
-import { BeforeStage, ModularStages, StageIndices, StageTuple } from '../stage'
-
-interface ModularMockMethodIndices<
-  Props extends {},
-  Ref,
-  Methods extends Record<string, MethodRecord>,
-  Stages extends StageTuple,
-  Method extends keyof Methods,
-  Indices extends number[],
-  Symbol extends keyof ModularStages = Methods[Method]['symbol'],
-> {
-  <
-    Arguments extends ComputeArguments<
-      Props,
-      Ref,
-      Methods,
-      BeforeStage<Stages, StageIndex>
-    >,
-    // Value validation
-    Value extends Stages[StageIndex]['value'],
-    Mock extends ModularStages<Arguments, Value>[Symbol] extends {
-      transform: infer T
-    }
-      ? T
-      : Value,
-    // Validate index
-    StageIndex extends Index extends number ? Indices[Index] : Last<Indices>,
-    ValidIndex extends ValidateIndex<Index, ToIndices<Indices>>,
-    Index extends number,
-  >(
-    mock: Mock,
-    index: ValidIndex extends true ? Index : ToIndices<Indices>,
-  ): ModularComponent<Props, Ref, Methods, Stages>
-}
-
-interface ModularMockMethodLast<
-  Props extends {},
-  Ref,
-  Methods extends Record<string, MethodRecord>,
-  Stages extends StageTuple,
-  Method extends keyof Methods,
-  Index extends number,
-  Symbol extends keyof ModularStages = Methods[Method]['symbol'],
-> {
-  <
-    // Value validation
-    Value extends Stages[Index]['value'],
-    Mock extends ModularStages<any, Value>[Symbol] extends {
-      transform: infer T
-    }
-      ? T
-      : Value,
-  >(
-    mock: Mock,
-  ): ModularComponent<Props, Ref, Methods, Stages>
-}
-
-type ModularMockMethod<
-  Props extends {},
-  Ref,
-  Methods extends Record<string, MethodRecord>,
-  Stages extends StageTuple,
-  Method extends keyof Methods,
-  Symbol extends keyof ModularStages = Methods[Method]['symbol'],
-  Indices extends StageIndices<Stages, Symbol> = StageIndices<Stages, Symbol>,
-> = Indices['length'] extends 0
-  ? never
-  : ModularMockMethodIndices<Props, Ref, Methods, Stages, Method, Indices> &
-      ModularMockMethodLast<Props, Ref, Methods, Stages, Method, Last<Indices>>
-
-export type ModularMockMethods<
-  Props extends {},
-  Ref,
-  Methods extends Record<string, MethodRecord>,
-  Stages extends StageTuple,
-> = FilterNever<{
-  [Method in keyof Methods as `mock${Method extends string
-    ? Method
-    : never}`]: ModularMockMethod<Props, Ref, Methods, Stages, Method>
-}>

package/src/types/methods/with.ts

@@ -1,173 +0,0 @@
-/**
- * Main factory methods adding or editing an entry for a given
- * stage. If multiple entries for the same stage were added
- * with the `add` method, an index can be passed to select the
- * entry to edit.
- */
-
-import { ModularComponent } from '../modular-component'
-import { Last, ToIndices } from '../utils'
-import {
-  BeforeStage,
-  ModularStages,
-  StageIndices,
-  StageTuple,
-  UpsertStage,
-} from '../stage'
-import { MethodRecord } from '../methods'
-import { ComputeArguments } from '../arguments'
-import { RestrictValue, ValidateIndex } from '../validation'
-
-interface ModularWithMethodDefault<
-  Props extends {},
-  Ref,
-  Methods extends Record<string, MethodRecord>,
-  Stages extends StageTuple,
-  Method extends keyof Methods,
-  Symbol extends keyof ModularStages = Methods[Method]['symbol'],
-  Arguments extends {} = ComputeArguments<Props, Ref, Methods, Stages>,
-> {
-  <Value extends RestrictValue<Arguments, Symbol>>(
-    ...args: undefined extends RestrictValue<Arguments, Symbol>
-      ? [value?: Value]
-      : [value: Value]
-  ): ModularComponent<
-    Props,
-    Ref,
-    Methods,
-    UpsertStage<Stages, { stage: Symbol; value: Value }>
-  >
-}
-
-interface ModularWithMethodIndices<
-  Props extends {},
-  Ref,
-  Methods extends Record<string, MethodRecord>,
-  Stages extends StageTuple,
-  Method extends keyof Methods,
-  Indices extends number[],
-  Symbol extends keyof ModularStages = Methods[Method]['symbol'],
-> {
-  <
-    Arguments extends ComputeArguments<
-      Props,
-      Ref,
-      Methods,
-      BeforeStage<Stages, StageIndex>
-    >,
-    // Validate value
-    Value extends RestrictValue<Arguments, Symbol>,
-    PreviousValue extends Stages[StageIndex]['value'],
-    Valid extends ModularStages<Arguments, Value>[Symbol] extends {
-      validate: infer V
-    }
-      ? V
-      : ModularStages<Arguments, Value>[Symbol] extends {
-          transform: infer V
-        }
-      ? V
-      : Value,
-    PreviousValid extends ModularStages<
-      Arguments,
-      PreviousValue
-    >[Symbol] extends {
-      validate: infer V
-    }
-      ? V
-      : ModularStages<Arguments, PreviousValue>[Symbol] extends {
-          transform: infer V
-        }
-      ? V
-      : PreviousValue,
-    ValidValue extends [Valid] extends [PreviousValid] ? true : false,
-    // Validate index
-    StageIndex extends Index extends number ? Indices[Index] : Last<Indices>,
-    ValidIndex extends ValidateIndex<Index, ToIndices<Indices>>,
-    Index extends number,
-  >(
-    value: ValidValue extends true ? Value : PreviousValue,
-    index: ValidIndex extends true ? Index : ToIndices<Indices>,
-  ): ModularComponent<
-    Props,
-    Ref,
-    Methods,
-    UpsertStage<Stages, { stage: Symbol; value: Value }, StageIndex>
-  >
-}
-
-interface ModularWithMethodLast<
-  Props extends {},
-  Ref,
-  Methods extends Record<string, MethodRecord>,
-  Stages extends StageTuple,
-  Method extends keyof Methods,
-  Index extends number,
-  Symbol extends keyof ModularStages = Methods[Method]['symbol'],
-  Arguments extends {} = ComputeArguments<
-    Props,
-    Ref,
-    Methods,
-    BeforeStage<Stages, Index>
-  >,
-> {
-  <
-    // Validate value
-    Value extends RestrictValue<Arguments, Symbol>,
-    PreviousValue extends Stages[Index]['value'],
-    Valid extends ModularStages<Arguments, Value>[Symbol] extends {
-      validate: infer V
-    }
-      ? V
-      : ModularStages<Arguments, Value>[Symbol] extends {
-          transform: infer V
-        }
-      ? V
-      : Value,
-    PreviousValid extends ModularStages<
-      Arguments,
-      PreviousValue
-    >[Symbol] extends {
-      validate: infer V
-    }
-      ? V
-      : ModularStages<Arguments, PreviousValue>[Symbol] extends {
-          transform: infer V
-        }
-      ? V
-      : PreviousValue,
-    ValidValue extends [Valid] extends [PreviousValid] ? true : false,
-  >(
-    ...args: undefined extends PreviousValue
-      ? [value?: ValidValue extends true ? Value : PreviousValue]
-      : [value: ValidValue extends true ? Value : PreviousValue]
-  ): ModularComponent<
-    Props,
-    Ref,
-    Methods,
-    UpsertStage<Stages, { stage: Symbol; value: Value }, Index>
-  >
-}
-
-type ModularWithMethod<
-  Props extends {},
-  Ref,
-  Methods extends Record<string, MethodRecord>,
-  Stages extends StageTuple,
-  Method extends keyof Methods,
-  Symbol extends keyof ModularStages = Methods[Method]['symbol'],
-  Indices extends StageIndices<Stages, Symbol> = StageIndices<Stages, Symbol>,
-> = Indices['length'] extends 0
-  ? ModularWithMethodDefault<Props, Ref, Methods, Stages, Method>
-  : ModularWithMethodIndices<Props, Ref, Methods, Stages, Method, Indices> &
-      ModularWithMethodLast<Props, Ref, Methods, Stages, Method, Last<Indices>>
-
-export type ModularWithMethods<
-  Props extends {},
-  Ref,
-  Methods extends Record<string, MethodRecord>,
-  Stages extends StageTuple,
-> = {
-  [Method in keyof Methods as `with${Method extends string
-    ? Method
-    : never}`]: ModularWithMethod<Props, Ref, Methods, Stages, Method>
-}

package/src/types/methods.ts

@@ -1,11 +0,0 @@
-/**
- * Helper types for handling method records
- */
-
-import { ModularStages } from './stage'
-
-export type MethodRecord = {
-  symbol: keyof ModularStages
-  field: string
-  transform?: (args: any, value: any) => any
-}

package/src/types/modular-component.ts

@@ -1,27 +0,0 @@
-/**
- * Main ModularComponent type
- */
-
-import { ForwardedRef, FunctionComponent, PropsWithChildren } from 'react'
-
-import { StageTuple } from './stage'
-import { MethodRecord } from './methods'
-import { ModularWithMethods } from './methods/with'
-import { ModularAddMethods } from './methods/add'
-import { ModularAtMethods } from './methods/at'
-import { ModularBeforeMethods } from './methods/before'
-import { ModularMockMethods } from './methods/mock'
-import { ModularHookMethods } from './methods/hook'
-
-export type ModularComponent<
-  Props extends {},
-  Ref,
-  Methods extends Record<string, MethodRecord>,
-  Stages extends StageTuple,
-> = ModularWithMethods<Props, Ref, Methods, Stages> &
-  ModularAddMethods<Props, Ref, Methods, Stages> &
-  ModularAtMethods<Props, Ref, Methods, Stages> &
-  ModularBeforeMethods<Props, Ref, Methods, Stages> &
-  ModularMockMethods<Props, Ref, Methods, Stages> &
-  ModularHookMethods<Props, Ref, Methods, Stages> &
-  FunctionComponent<PropsWithChildren<Props & { ref?: ForwardedRef<Ref> }>>

package/src/types/stage.ts

@@ -1,91 +0,0 @@
-/**
- * Helper for manipulating stages and stage tuples
- */
-
-import { At, Before, Reduce, After, OneLess } from './utils'
-
-export interface ModularStages<Args = any, Value = any> {}
-
-type StageRecord = {
-  stage: keyof ModularStages
-  value: unknown
-}
-export type StageTuple = StageRecord[]
-
-export type AddStage<List extends StageTuple, Stage extends StageRecord> = [
-  ...List,
-  Stage,
-]
-
-export type ReplaceStageAt<
-  List extends StageTuple,
-  Stage extends StageRecord,
-  At extends number | string,
-> = {
-  [Index in keyof List]: Index extends At
-    ? List[Index]['stage'] extends Stage['stage']
-      ? Stage
-      : List[Index]
-    : List[Index]
-}
-
-type ReplaceStage<
-  List extends StageTuple,
-  Stage extends StageRecord,
-  At extends number | string = never,
-> = [At] extends [never]
-  ? {
-      [Index in keyof List]: List[Index]['stage'] extends Stage['stage']
-        ? Stage
-        : List[Index]
-    }
-  : ReplaceStageAt<List, Stage, At>
-
-export type ExtractStage<
-  List extends StageTuple,
-  Stage extends symbol,
-  Union = List[number],
-> = Union extends { stage: Stage; value: infer U }
-  ? { stage: Stage; value: U }
-  : never
-
-export type UpsertStage<
-  List extends StageTuple,
-  Stage extends StageRecord,
-  At extends number = never,
-> = [ExtractStage<List, Stage['stage']>] extends [never]
-  ? AddStage<List, Stage>
-  : ReplaceStage<List, Stage, At>
-
-type IsolateStage<Tuple extends StageTuple, Stage extends symbol> = {
-  [key in keyof Tuple]: Tuple[key]['stage'] extends Stage ? key : never
-}
-
-export type StageIndices<
-  Tuple extends StageTuple,
-  Stage extends symbol,
-> = Reduce<IsolateStage<Tuple, Stage>>
-
-export type AtStage<
-  Tuple extends StageTuple,
-  Index extends number | string,
-> = At<Tuple, Index> extends StageTuple ? At<Tuple, Index> : []
-
-export type BeforeStage<
-  Tuple extends StageTuple,
-  Index extends number | string,
-> = Before<Tuple, Index> extends StageTuple ? Before<Tuple, Index> : []
-
-type AfterStage<
-  Tuple extends StageTuple,
-  Index extends number | string,
-> = After<Tuple, Index> extends StageTuple ? After<Tuple, Index> : []
-
-export type CleanUpStages<Tuple extends StageTuple> = {
-  [key in keyof Tuple]: StageIndices<
-    OneLess<AfterStage<Tuple, key>>,
-    Tuple[key]['stage']
-  >['length'] extends 0
-    ? Tuple[key]
-    : never
-}

package/src/types/utils.ts

@@ -1,63 +0,0 @@
-/**
- * Generic type helpers (tuple, union, object...)
- */
-
-// Tuple handling
-export type OneLess<Tuple extends unknown[]> = Tuple extends [
-  unknown,
-  ...infer Rest,
-]
-  ? Rest
-  : Tuple
-export type Before<
-  Tuple extends unknown[],
-  Index extends string | number,
-> = `${Tuple['length']}` extends `${Index}`
-  ? Tuple
-  : Tuple extends [...infer Keep, infer Drop]
-  ? Before<Keep, Index>
-  : never
-export type After<
-  Tuple extends unknown[],
-  Index extends string | number,
-  Rest extends unknown[] = [],
-> = `${Rest['length']}` extends `${Index}`
-  ? Tuple
-  : Tuple extends [infer Drop, ...infer Keep]
-  ? After<Keep, Index, [...Rest, Drop]>
-  : never
-export type At<
-  Tuple extends unknown[],
-  Index extends string | number,
-> = `${OneLess<Tuple>['length']}` extends `${Index}`
-  ? Tuple
-  : Tuple extends [...infer Keep, infer Drop]
-  ? At<Keep, Index>
-  : never
-export type Reduce<T extends unknown[]> = T extends [...infer R, infer L]
-  ? [L] extends [never]
-    ? [...Reduce<R>]
-    : [...Reduce<R>, L]
-  : T
-export type ToIndices<T extends unknown[]> = { [key in keyof T]: key }[number]
-export type Last<T extends unknown[]> = T extends [...infer R, infer L]
-  ? L
-  : never
-
-// Union handling
-
-// Collapse a union of similar object into the intersection of the various objects
-export type UnionToIntersection<U> = [U] extends [never]
-  ? never
-  : (U extends infer V ? (k: U) => void : never) extends (k: infer I) => void
-  ? I
-  : never
-
-// Object handling
-type NonNeverKeys<Obj extends {}> = {
-  [key in keyof Obj]: Obj[key] extends never ? never : key
-}[keyof Obj]
-
-export type FilterNever<Obj extends {}> = {
-  [key in NonNeverKeys<Obj>]: Obj[key]
-}

package/src/types/validation.ts

@@ -1,13 +0,0 @@
-import { ModularStages } from './stage'
-
-export type ValidateIndex<
-  Index extends number | undefined,
-  Candidates extends string | number,
-> = `${Index}` extends Candidates ? true : false
-
-export type RestrictValue<
-  Arguments extends {},
-  Stage extends keyof ModularStages,
-> = ModularStages<Arguments>[Stage]['restrict'] extends never
-  ? unknown
-  : ModularStages<Arguments>[Stage]['restrict']