@modular-component/core 0.1.7 → 0.2.0

package/src/index.ts

@@ -1,256 +1,171 @@
-import { ForwardedRef, FunctionComponent, forwardRef, memo } from 'react'
-
-import { ModularComponent } from './types/modular-component'
-import { MethodRecord } from './types/methods'
-import { StageTuple } from './types/stage'
-
-export type { ModularStages } from './types/stage'
-
-function ModularFactory<Methods extends Record<string, MethodRecord>>(
-  methods: Methods,
-) {
-  type CleanMethods = Methods extends infer U
-    ? { [key in keyof U]: U[key] }
-    : never
-
-  return {
-    build: <Stages extends StageTuple = []>(stages: StageTuple = []) => {
-      const factory = <Props extends {} = {}, Ref = FunctionComponent<Props>>(
-        displayName?: string,
-        options?: { memo: boolean },
-      ) => {
-        const generateAsHook =
-          (ref?: ForwardedRef<Ref>, field?: string) =>
-          () =>
-          (props: Props = {} as Props) => {
-            // Prepare the shared arguments object, prefilling it with the props
-            // and an empty render result
-            let args = {
-              props,
-              children: (props as { children?: unknown })?.children,
-              render: null,
-              ref,
-            }
-
-            const methodsArray = Object.values(methods)
-
-            // Run each stage in order, replacing the arguments by the response
-            // from the last stage
-            for (const stage of stages) {
-              const method = methodsArray.find(
-                (method) => method.symbol === stage.stage,
-              )
-
-              let useTransform =
-                // Never transform mocked stages
-                ((stage as any).mocked ? undefined : method?.transform) ??
-                (() => stage.value)
-
-              args = {
-                ...args,
-                [method?.field as keyof typeof args]: useTransform(
-                  args,
-                  stage.value,
-                ),
-              }
-            }
-
-            // Finally, return the args
-            return field ? args[field as keyof typeof args] : args
-          }
-
-        // Create the actual Component. This is a simple React Functional Component
-        // that will call the hooks for each registered stages in order.
-        const Component = forwardRef<Ref, Props>((props, ref) => {
-          // Prepare the shared arguments object, prefilling it with the props
-          // and an empty render result
-          const useComponent = generateAsHook(ref)()
-          const args = useComponent(props)
-
-          return (args as unknown as { render: null }).render ?? null
-        }) as unknown as ModularComponent<Props, Ref, CleanMethods, Stages>
-
-        // Set the debug display name if provided
-        Component.displayName = displayName
-
-        // Add an asHook system to get the components args as a reusable hook
-        Component.asHook = generateAsHook() as ModularComponent<
-          Props,
-          Ref,
-          CleanMethods,
-          Stages
-        >['asHook']
-
-        // Add each configured stage methods to the component
-        Object.keys(methods).forEach((method) => {
-          // Check if a stage of the same key already exists
-          const stageIndices = stages
-            // Map all stages to an [index, stage] tuple
-            .map((record, index) => [index, record] as const)
-            // Remove all tuples not matching our stage
-            .filter(([, record]) => record.stage === methods[method].symbol)
-            // Get the index
-            .map(([index]) => index)
-          const lastIndex = [...stageIndices].pop() as number
-
-          // @ts-ignore
-          Component[`with${method}`] = (
-            value: unknown,
-            forceIndex?: number,
-          ) => {
-            // Prepare the new stage
-            const stage = { stage: methods[method].symbol, value } as const
-
-            // Check if a stage of the same key already exists
-            const stageIndex =
-              (forceIndex !== undefined
-                ? stageIndices[forceIndex]
-                : lastIndex) ?? -1
-
-            // If so, copy the stages and replace the previous record
-            if (stageIndex > -1) {
-              const nextStages = [...stages]
-              nextStages[stageIndex] = stage
-              return ModularFactory(methods).build(nextStages)<Props>(
-                displayName,
-              )
-            }
-
-            // Otherwise, append the stage
-            return ModularFactory(methods).build([...stages, stage])<Props>(
-              displayName,
-            )
-          }
-
-          // @ts-ignore
-          Component[`add${method}`] =
-            stageIndices.length < 1
-              ? undefined
-              : (value: unknown) => {
-                  // Prepare the new stage
-                  const stage = {
-                    stage: methods[method].symbol,
-                    value,
-                  } as const
-
-                  // Append the stage as in multiple mode
-                  return ModularFactory(methods).build([
-                    ...stages,
-                    stage,
-                  ])<Props>(displayName)
-                }
-
-          // @ts-ignore
-          Component[`at${method}`] =
-            stageIndices.length < 1
-              ? undefined
-              : (forceIndex?: number) => {
-                  // Find the needed stage
-                  const stageIndex =
-                    (forceIndex !== undefined
-                      ? stageIndices[forceIndex]
-                      : lastIndex) ?? lastIndex
-
-                  // Otherwise, keep all stages up to and including the found stage
-                  return ModularFactory<Methods>(methods).build(
-                    stages.slice(0, stageIndex + 1),
-                  )<Props>(displayName)
-                }
-
-          // @ts-ignore
-          Component[`before${method}`] =
-            stageIndices.length < 1
-              ? undefined
-              : (forceIndex?: number) => {
-                // Find the needed stage
-                const stageIndex =
-                  (forceIndex !== undefined
-                    ? stageIndices[forceIndex]
-                    : lastIndex) ?? lastIndex
-
-                // Otherwise, keep all stages up to but excluding the found stage
-                return ModularFactory<Methods>(methods).build(
-                  stages.slice(0, stageIndex),
-                )<Props>(displayName)
-              }
+import React, {
+  ForwardRefRenderFunction,
+  FunctionComponent,
+  PropsWithChildren,
+} from 'react'
+
+export interface ModularStage<
+  Field extends string,
+  Stage extends (args: any, ref?: any) => any,
+> {
+  field: Field
+  useStage: Stage
+}
 
-          // @ts-ignore
-          Component[`mock${method}`] =
-            stageIndices.length < 1
-              ? () => Component as unknown
-              : (value: unknown, forceIndex?: number) => {
-                  // Prepare the mocked stage
-                  const stage = {
-                    stage: methods[method].symbol,
-                    value,
-                    mocked: true,
-                  } as const
+export type FunctionComponentOrRefRenderFunction<Props, Ref> = [Ref] extends [
+  never,
+]
+  ? FunctionComponent<PropsWithChildren<Props>>
+  : ForwardRefRenderFunction<Ref, Props>
+
+export type ModularComponent<
+  Props extends {},
+  Ref,
+  Args extends { render: ReturnType<FunctionComponent> },
+> = FunctionComponentOrRefRenderFunction<Props, Ref> & {
+  with<Field extends string, Type>(stage: {
+    field: Field
+    useStage: (
+      args: Args,
+      ref: React.ForwardedRef<Ref>,
+    ) => Field extends keyof Args ? Args[Field] : Type
+  }): ModularComponent<
+    Props,
+    Ref,
+    {
+      [key in keyof Args | Field]: key extends 'render'
+        ? ReturnType<FunctionComponent>
+        : key extends Field
+        ? Type
+        : key extends keyof Args
+        ? Args[key]
+        : never
+    }
+  >
+  force<Field extends string, Type>(stage: {
+    field: Field
+    useStage: (
+      args: Args,
+      ref: React.ForwardedRef<Ref>,
+    ) => Field extends 'render' ? Args['render'] : Type
+  }): ModularComponent<
+    Props,
+    Ref,
+    {
+      [key in keyof Args | Field]: key extends 'render'
+        ? ReturnType<FunctionComponent>
+        : key extends Field
+        ? Type
+        : key extends keyof Args
+        ? Args[key]
+        : never
+    }
+  >
+  use<Field extends keyof Args>(
+    key: Field,
+  ): {} extends Props ? () => Args[Field] : (props: PropsWithChildren<Props>) => Args[Field]
+  use(): {} extends Props ? () => Args : (props: PropsWithChildren<Props>) => Args
+  stage<Field extends keyof Args>(
+    key: Field,
+  ): (args: Partial<Args>) => Args[Field]
+  setDisplayName(displayName: string): ModularComponent<Props, Ref, Args>
+}
 
-                  // Find the needed stage
-                  const stageIndex =
-                    (forceIndex !== undefined
-                      ? stageIndices[forceIndex]
-                      : lastIndex) ?? lastIndex
+function InternalFactory<
+  Props extends {},
+  Ref,
+  Args extends { render: ReturnType<FunctionComponent> },
+>(
+  stages: ModularStage<
+    string,
+    (args: Args, ref: React.ForwardedRef<Ref>) => any
+  >[],
+): ModularComponent<Props, Ref, Args> {
+  const useComponent = function (props: Props, ref: React.ForwardedRef<Ref>) {
+    if (!stages.some((stage) => stage.field === 'render')) {
+      stages = [...stages, render(() => null)]
+    }
+    return useComponent.use('render')(props, ref)
+  }
 
-                  // Replace the stage with its mock
-                  const nextStages = [...stages]
-                  nextStages[stageIndex] = stage
-                  return ModularFactory(methods).build(nextStages)<Props>(
-                    displayName,
-                  )
-                }
+  useComponent.with = (stage: ModularStage<string, (args: Args) => any>) => {
+    const index = stages.findIndex((s) => s.field === stage.field)
 
-          const capitalize = (str: string) =>
-            str[0].toUpperCase() + str.slice(1)
+    if (index !== -1) {
+      const next = [...stages]
+      next[index] = stage
+      return InternalFactory<Props, Ref, Args>(next)
+    }
 
-          // @ts-ignore
-          Component[`asUse${capitalize(methods[method].field)}`] =
-            generateAsHook(undefined, methods[method].field)
-        })
+    return InternalFactory<Props, Ref, Args>([...stages, stage])
+  }
+  useComponent.force = useComponent.with
+
+  useComponent.use =
+    (field: keyof Args) => (props: Props, ref: React.ForwardedRef<Ref>) => {
+      const args: Record<string, any> = { props }
+      const index = field
+        ? stages.findIndex((stage) => stage.field === field)
+        : false
+
+      if (index === false) {
+        for (let stage of stages) {
+          args[stage.field] = stage.useStage(args as Args, ref)
+        }
+        return args
+      }
 
-        return (options?.memo ? memo(Component) : Component) as typeof Component
+      const argStages =
+        index === -1 ? stages.slice(0) : stages.slice(0, index + 1)
+      const returnStage = argStages.pop()
+      for (let stage of argStages) {
+        args[stage.field] = stage.useStage(args as Args, ref)
       }
+      return returnStage?.useStage(args as Args, ref) ?? null
+    }
 
-      factory.memo = <Props extends {} = {}, Ref = FunctionComponent<Props>>(
-        displayName?: string,
-      ) => factory<Props, Ref>(displayName, { memo: true })
+  useComponent.stage = (field: keyof Args) => {
+    const stage = stages.find((stage) => stage.field === field)
+    return stage?.useStage ?? (() => null)
+  }
 
-      return factory
-    },
-    extend: <_Methods extends Record<string, MethodRecord>>(
-      _methods: _Methods,
-    ) => {
-      return ModularFactory<Methods & _Methods>({
-        ...methods,
-        ..._methods,
-      })
-    },
+  useComponent.setDisplayName = (displayName: string) => {
+    ;(useComponent as any).displayName = displayName
   }
-}
 
-const withRender = Symbol()
+  return useComponent as unknown as ModularComponent<Props, Ref, Args>
+}
 
-declare module './types/stage' {
-  export interface ModularStages<Args, Value> {
-    [withRender]: {
-      restrict: FunctionComponent<Args>
-      transform: ReturnType<
-        Value extends FunctionComponent<Args> ? Value : never
-      >
-    }
-  }
+export function ModularComponent<Props extends {} = {}, Ref = never>(
+  displayName?: string,
+): ModularComponent<
+  Props,
+  Ref,
+  { props: Props; render: ReturnType<FunctionComponent> }
+> {
+  const useComponent = InternalFactory<
+    Props,
+    Ref,
+    { props: Props; render: ReturnType<FunctionComponent> }
+  >([])
+  useComponent.displayName = displayName
+  return useComponent
 }
 
-export const modularFactory = ModularFactory({
-  Render: {
-    symbol: withRender,
+export function render<Args extends {}, Ref>(
+  render: (
+    args: Args,
+    ref: React.ForwardedRef<Ref>,
+  ) => React.ReactElement<any, any> | null,
+): ModularStage<
+  'render',
+  (
+    args: Args,
+    ref: React.ForwardedRef<Ref>,
+  ) => React.ReactElement<any, any> | null
+> {
+  return {
     field: 'render',
-    transform: (args, useStage) => useStage(args),
-  },
-} as const)
-
-export function createMethodRecord<R extends Record<string, MethodRecord>>(
-  record: R,
-): R {
-  return record
+    useStage: render,
+  }
 }

package/dist/types/arguments.d.ts

@@ -1,33 +0,0 @@
-/**
- * Helpers for computing the arguments map generated by a given
- * set of stages
- */
-import { PropsWithChildren } from 'react';
-import { StageTuple, ModularStages, BeforeStage, CleanUpStages } from './stage';
-import { UnionToIntersection } from './utils';
-export declare type ComputeArguments<Props extends {}, Ref, Methods extends Record<string, {
-    symbol: keyof ModularStages;
-    field: string;
-}>, Stages extends StageTuple, CleanedStages extends StageTuple = CleanUpStages<Stages>, MethodList = Methods[keyof Methods]> = {
-    props: Props extends {
-        children: unknown;
-    } ? Props : PropsWithChildren<Props>;
-    ref: Ref;
-    children: Props extends {
-        children: infer C;
-    } ? C : PropsWithChildren['children'];
-} & (Stages['length'] extends 0 ? {} : UnionToIntersection<{
-    [key in keyof CleanedStages]: MethodList extends {
-        symbol: CleanedStages[key]['stage'];
-        field: infer F;
-    } ? {
-        [k in F extends string ? F : never]: ModularStages<ComputeArguments<Props, Ref, Methods, BeforeStage<CleanedStages, key>>, CleanedStages[key]['value']>[CleanedStages[key]['stage']] extends {
-            transform: infer T;
-        } ? T : CleanedStages[key]['value'];
-    } : never;
-}[number]>) extends infer U ? {
-    [key in keyof U]: U[key] extends Record<string, unknown> ? U[key] extends infer V ? {
-        [key in keyof V]: V[key];
-    } : never : U[key];
-} : never;
-//# sourceMappingURL=arguments.d.ts.map

package/dist/types/arguments.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"arguments.d.ts","sourceRoot":"","sources":["../../src/types/arguments.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,iBAAiB,EAAE,MAAM,OAAO,CAAA;AACzC,OAAO,EAAE,UAAU,EAAE,aAAa,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,SAAS,CAAA;AAC/E,OAAO,EAAE,mBAAmB,EAAE,MAAM,SAAS,CAAA;AAE7C,oBAAY,gBAAgB,CAC1B,KAAK,SAAS,EAAE,EAChB,GAAG,EACH,OAAO,SAAS,MAAM,CACpB,MAAM,EACN;IAAE,MAAM,EAAE,MAAM,aAAa,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAC/C,EACD,MAAM,SAAS,UAAU,EACzB,aAAa,SAAS,UAAU,GAAG,aAAa,CAAC,MAAM,CAAC,EACxD,UAAU,GAAG,OAAO,CAAC,MAAM,OAAO,CAAC,IACjC;IACF,KAAK,EAAE,KAAK,SAAS;QAAE,QAAQ,EAAE,OAAO,CAAA;KAAE,GAAG,KAAK,GAAG,iBAAiB,CAAC,KAAK,CAAC,CAAA;IAC7E,GAAG,EAAE,GAAG,CAAA;IACR,QAAQ,EAAE,KAAK,SAAS;QAAE,QAAQ,EAAE,MAAM,CAAC,CAAA;KAAE,GACzC,CAAC,GACD,iBAAiB,CAAC,UAAU,CAAC,CAAA;CAClC,GAAG,CAAC,MAAM,CAAC,QAAQ,CAAC,SAAS,CAAC,GAC3B,EAAE,GACF,mBAAmB,CACjB;KACG,GAAG,IAAI,MAAM,aAAa,GAAG,UAAU,SAAS;QAC/C,MAAM,EAAE,aAAa,CAAC,GAAG,CAAC,CAAC,OAAO,CAAC,CAAA;QACnC,KAAK,EAAE,MAAM,CAAC,CAAA;KACf,GACG;SACG,CAAC,IAAI,CAAC,SAAS,MAAM,GAAG,CAAC,GAAG,KAAK,GAAG,aAAa,CAChD,gBAAgB,CACd,KAAK,EACL,GAAG,EACH,OAAO,EACP,WAAW,CAAC,aAAa,EAAE,GAAG,CAAC,CAChC,EACD,aAAa,CAAC,GAAG,CAAC,CAAC,OAAO,CAAC,CAC5B,CAAC,aAAa,CAAC,GAAG,CAAC,CAAC,OAAO,CAAC,CAAC,SAAS;YAAE,SAAS,EAAE,MAAM,CAAC,CAAA;SAAE,GACzD,CAAC,GACD,aAAa,CAAC,GAAG,CAAC,CAAC,OAAO,CAAC;KAChC,GACD,KAAK;CACV,CAAC,MAAM,CAAC,CACV,CAAC,SAAS,MAAM,CAAC,GAClB;KACG,GAAG,IAAI,MAAM,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GACpD,CAAC,CAAC,GAAG,CAAC,SAAS,MAAM,CAAC,GACpB;SAAG,GAAG,IAAI,MAAM,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC;KAAE,GAC5B,KAAK,GACP,CAAC,CAAC,GAAG,CAAC;CACX,GACD,KAAK,CAAA"}

package/dist/types/arguments.js

@@ -1,6 +0,0 @@
-/**
- * Helpers for computing the arguments map generated by a given
- * set of stages
- */
-export {};
-//# sourceMappingURL=arguments.js.map

package/dist/types/arguments.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"arguments.js","sourceRoot":"","sources":["../../src/types/arguments.ts"],"names":[],"mappings":"AAAA;;;GAGG"}

package/dist/types/methods/add.d.ts

@@ -1,23 +0,0 @@
-/**
- * Methods for adding a new entry for a previous stage, rather
- * than reusing the previous one.
- * One two entries for the same stage have been added, `with`, `at` and
- * `mock` methods can take an optional index to select the entry to target
- */
-import { ModularComponent } from '../modular-component';
-import { AddStage, ModularStages, StageIndices, StageTuple } from '../stage';
-import { ComputeArguments } from '../arguments';
-import { RestrictValue } from '../validation';
-import { MethodRecord } from '../methods';
-import { FilterNever } from '../utils';
-interface ModularAddMethod<Props extends {}, Ref, Methods extends Record<string, MethodRecord>, Stages extends StageTuple, Method extends keyof Methods, Symbol extends keyof ModularStages = Methods[Method]['symbol']> {
-    <Value extends RestrictValue<Arguments, Symbol>, Arguments extends ComputeArguments<Props, Ref, Methods, Stages>>(...args: undefined extends RestrictValue<Arguments, Symbol> ? [value?: Value] : [value: Value]): ModularComponent<Props, Ref, Methods, AddStage<Stages, {
-        stage: Symbol;
-        value: Value;
-    }>>;
-}
-export declare type ModularAddMethods<Props extends {}, Ref, Methods extends Record<string, MethodRecord>, Stages extends StageTuple> = FilterNever<{
-    [Method in keyof Methods as `add${Method extends string ? Method : never}`]: StageIndices<Stages, Methods[Method]['symbol']>['length'] extends 0 ? never : ModularAddMethod<Props, Ref, Methods, Stages, Method>;
-}>;
-export {};
-//# sourceMappingURL=add.d.ts.map

package/dist/types/methods/add.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"add.d.ts","sourceRoot":"","sources":["../../../src/types/methods/add.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAA;AACvD,OAAO,EAAE,QAAQ,EAAE,aAAa,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,UAAU,CAAA;AAC5E,OAAO,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAA;AAC/C,OAAO,EAAE,aAAa,EAAE,MAAM,eAAe,CAAA;AAC7C,OAAO,EAAE,YAAY,EAAE,MAAM,YAAY,CAAA;AACzC,OAAO,EAAE,WAAW,EAAE,MAAM,UAAU,CAAA;AAEtC,UAAU,gBAAgB,CACxB,KAAK,SAAS,EAAE,EAChB,GAAG,EACH,OAAO,SAAS,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,EAC5C,MAAM,SAAS,UAAU,EACzB,MAAM,SAAS,MAAM,OAAO,EAC5B,MAAM,SAAS,MAAM,aAAa,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC,QAAQ,CAAC;IAE9D,CACE,KAAK,SAAS,aAAa,CAAC,SAAS,EAAE,MAAM,CAAC,EAC9C,SAAS,SAAS,gBAAgB,CAAC,KAAK,EAAE,GAAG,EAAE,OAAO,EAAE,MAAM,CAAC,EAE/D,GAAG,IAAI,EAAE,SAAS,SAAS,aAAa,CAAC,SAAS,EAAE,MAAM,CAAC,GACvD,CAAC,KAAK,CAAC,EAAE,KAAK,CAAC,GACf,CAAC,KAAK,EAAE,KAAK,CAAC,GACjB,gBAAgB,CACjB,KAAK,EACL,GAAG,EACH,OAAO,EACP,QAAQ,CAAC,MAAM,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,KAAK,CAAA;KAAE,CAAC,CAClD,CAAA;CACF;AAED,oBAAY,iBAAiB,CAC3B,KAAK,SAAS,EAAE,EAChB,GAAG,EACH,OAAO,SAAS,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,EAC5C,MAAM,SAAS,UAAU,IACvB,WAAW,CAAC;KACb,MAAM,IAAI,MAAM,OAAO,IAAI,MAAM,MAAM,SAAS,MAAM,GACnD,MAAM,GACN,KAAK,EAAE,GAAG,YAAY,CACxB,MAAM,EACN,OAAO,CAAC,MAAM,CAAC,CAAC,QAAQ,CAAC,CAC1B,CAAC,QAAQ,CAAC,SAAS,CAAC,GACjB,KAAK,GACL,gBAAgB,CAAC,KAAK,EAAE,GAAG,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,CAAC;CAC1D,CAAC,CAAA"}

package/dist/types/methods/add.js

@@ -1,8 +0,0 @@
-/**
- * Methods for adding a new entry for a previous stage, rather
- * than reusing the previous one.
- * One two entries for the same stage have been added, `with`, `at` and
- * `mock` methods can take an optional index to select the entry to target
- */
-export {};
-//# sourceMappingURL=add.js.map

package/dist/types/methods/add.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"add.js","sourceRoot":"","sources":["../../../src/types/methods/add.ts"],"names":[],"mappings":"AAAA;;;;;GAKG"}

package/dist/types/methods/at.d.ts

@@ -1,22 +0,0 @@
-/**
- * Methods for rewinding a modular component up to a given stage.
- * If multiple entries of the same stage were previously added,
- * it's possible to pass the index for the entry to rewind to.
- */
-import { ModularComponent } from '../modular-component';
-import { AtStage, StageIndices, StageTuple } from '../stage';
-import { FilterNever, Last, ToIndices } from '../utils';
-import { ValidateIndex } from '../validation';
-import { MethodRecord } from '../methods';
-interface ModularAtMethodIndices<Props extends {}, Ref, Methods extends Record<string, MethodRecord>, Stages extends StageTuple, Method extends keyof Methods, Indices extends number[]> {
-    <StageIndex extends Index extends number ? Indices[Index] : Last<Indices>, ValidIndex extends ValidateIndex<Index, ToIndices<Indices>>, Index extends number>(index: ValidIndex extends true ? Index : ToIndices<Indices>): ModularComponent<Props, Ref, Methods, AtStage<Stages, StageIndex>>;
-}
-interface ModularAtMethodLast<Props extends {}, Ref, Methods extends Record<string, MethodRecord>, Stages extends StageTuple, Method extends keyof Methods, Index extends number> {
-    (): ModularComponent<Props, Ref, Methods, AtStage<Stages, Index>>;
-}
-declare type ModularAtMethod<Props extends {}, Ref, Methods extends Record<string, MethodRecord>, Stages extends StageTuple, Method extends keyof Methods, Symbol extends symbol = Methods[Method]['symbol'], Indices extends StageIndices<Stages, Symbol> = StageIndices<Stages, Symbol>> = Indices['length'] extends 0 ? never : ModularAtMethodIndices<Props, Ref, Methods, Stages, Method, Indices> & ModularAtMethodLast<Props, Ref, Methods, Stages, Method, Last<Indices>>;
-export declare type ModularAtMethods<Props extends {}, Ref, Methods extends Record<string, MethodRecord>, Stages extends StageTuple> = FilterNever<{
-    [Method in keyof Methods as `at${Method extends string ? Method : never}`]: ModularAtMethod<Props, Ref, Methods, Stages, Method>;
-}>;
-export {};
-//# sourceMappingURL=at.d.ts.map

package/dist/types/methods/at.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"at.d.ts","sourceRoot":"","sources":["../../../src/types/methods/at.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAA;AACvD,OAAO,EAAE,OAAO,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,UAAU,CAAA;AAC5D,OAAO,EAAE,WAAW,EAAE,IAAI,EAAE,SAAS,EAAE,MAAM,UAAU,CAAA;AACvD,OAAO,EAAE,aAAa,EAAE,MAAM,eAAe,CAAA;AAC7C,OAAO,EAAE,YAAY,EAAE,MAAM,YAAY,CAAA;AAEzC,UAAU,sBAAsB,CAC9B,KAAK,SAAS,EAAE,EAChB,GAAG,EACH,OAAO,SAAS,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,EAC5C,MAAM,SAAS,UAAU,EACzB,MAAM,SAAS,MAAM,OAAO,EAC5B,OAAO,SAAS,MAAM,EAAE;IAExB,CAEE,UAAU,SAAS,KAAK,SAAS,MAAM,GAAG,OAAO,CAAC,KAAK,CAAC,GAAG,IAAI,CAAC,OAAO,CAAC,EACxE,UAAU,SAAS,aAAa,CAAC,KAAK,EAAE,SAAS,CAAC,OAAO,CAAC,CAAC,EAC3D,KAAK,SAAS,MAAM,EAEpB,KAAK,EAAE,UAAU,SAAS,IAAI,GAAG,KAAK,GAAG,SAAS,CAAC,OAAO,CAAC,GAC1D,gBAAgB,CAAC,KAAK,EAAE,GAAG,EAAE,OAAO,EAAE,OAAO,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC,CAAA;CACtE;AAED,UAAU,mBAAmB,CAC3B,KAAK,SAAS,EAAE,EAChB,GAAG,EACH,OAAO,SAAS,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,EAC5C,MAAM,SAAS,UAAU,EACzB,MAAM,SAAS,MAAM,OAAO,EAC5B,KAAK,SAAS,MAAM;IAEpB,IAAI,gBAAgB,CAAC,KAAK,EAAE,GAAG,EAAE,OAAO,EAAE,OAAO,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC,CAAA;CAClE;AAED,aAAK,eAAe,CAClB,KAAK,SAAS,EAAE,EAChB,GAAG,EACH,OAAO,SAAS,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,EAC5C,MAAM,SAAS,UAAU,EACzB,MAAM,SAAS,MAAM,OAAO,EAC5B,MAAM,SAAS,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC,QAAQ,CAAC,EACjD,OAAO,SAAS,YAAY,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,YAAY,CAAC,MAAM,EAAE,MAAM,CAAC,IACzE,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAC,GAC3B,KAAK,GACL,sBAAsB,CAAC,KAAK,EAAE,GAAG,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,CAAC,GAClE,mBAAmB,CAAC,KAAK,EAAE,GAAG,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC,CAAA;AAE7E,oBAAY,gBAAgB,CAC1B,KAAK,SAAS,EAAE,EAChB,GAAG,EACH,OAAO,SAAS,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,EAC5C,MAAM,SAAS,UAAU,IACvB,WAAW,CAAC;KACb,MAAM,IAAI,MAAM,OAAO,IAAI,KAAK,MAAM,SAAS,MAAM,GAClD,MAAM,GACN,KAAK,EAAE,GAAG,eAAe,CAAC,KAAK,EAAE,GAAG,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,CAAC;CACnE,CAAC,CAAA"}

package/dist/types/methods/at.js

@@ -1,7 +0,0 @@
-/**
- * Methods for rewinding a modular component up to a given stage.
- * If multiple entries of the same stage were previously added,
- * it's possible to pass the index for the entry to rewind to.
- */
-export {};
-//# sourceMappingURL=at.js.map

package/dist/types/methods/at.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"at.js","sourceRoot":"","sources":["../../../src/types/methods/at.ts"],"names":[],"mappings":"AAAA;;;;GAIG"}

package/dist/types/methods/before.d.ts

@@ -1,22 +0,0 @@
-/**
- * Methods for rewinding a modular component up to a given stage.
- * If multiple entries of the same stage were previously added,
- * it's possible to pass the index for the entry to rewind to.
- */
-import { ModularComponent } from '../modular-component';
-import { BeforeStage, StageIndices, StageTuple } from '../stage';
-import { FilterNever, Last, ToIndices } from '../utils';
-import { ValidateIndex } from '../validation';
-import { MethodRecord } from '../methods';
-interface ModularBeforeMethodIndices<Props extends {}, Ref, Methods extends Record<string, MethodRecord>, Stages extends StageTuple, Method extends keyof Methods, Indices extends number[]> {
-    <StageIndex extends Index extends number ? Indices[Index] : Last<Indices>, ValidIndex extends ValidateIndex<Index, ToIndices<Indices>>, Index extends number>(index: ValidIndex extends true ? Index : ToIndices<Indices>): ModularComponent<Props, Ref, Methods, BeforeStage<Stages, StageIndex>>;
-}
-interface ModularBeforeMethodLast<Props extends {}, Ref, Methods extends Record<string, MethodRecord>, Stages extends StageTuple, Method extends keyof Methods, Index extends number> {
-    (): ModularComponent<Props, Ref, Methods, BeforeStage<Stages, Index>>;
-}
-declare type ModularBeforeMethod<Props extends {}, Ref, Methods extends Record<string, MethodRecord>, Stages extends StageTuple, Method extends keyof Methods, Symbol extends symbol = Methods[Method]['symbol'], Indices extends StageIndices<Stages, Symbol> = StageIndices<Stages, Symbol>> = Indices['length'] extends 0 ? never : ModularBeforeMethodIndices<Props, Ref, Methods, Stages, Method, Indices> & ModularBeforeMethodLast<Props, Ref, Methods, Stages, Method, Last<Indices>>;
-export declare type ModularBeforeMethods<Props extends {}, Ref, Methods extends Record<string, MethodRecord>, Stages extends StageTuple> = FilterNever<{
-    [Method in keyof Methods as `before${Method extends string ? Method : never}`]: ModularBeforeMethod<Props, Ref, Methods, Stages, Method>;
-}>;
-export {};
-//# sourceMappingURL=before.d.ts.map

package/dist/types/methods/before.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"before.d.ts","sourceRoot":"","sources":["../../../src/types/methods/before.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAA;AACvD,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,UAAU,CAAA;AAChE,OAAO,EAAE,WAAW,EAAE,IAAI,EAAE,SAAS,EAAE,MAAM,UAAU,CAAA;AACvD,OAAO,EAAE,aAAa,EAAE,MAAM,eAAe,CAAA;AAC7C,OAAO,EAAE,YAAY,EAAE,MAAM,YAAY,CAAA;AAEzC,UAAU,0BAA0B,CAClC,KAAK,SAAS,EAAE,EAChB,GAAG,EACH,OAAO,SAAS,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,EAC5C,MAAM,SAAS,UAAU,EACzB,MAAM,SAAS,MAAM,OAAO,EAC5B,OAAO,SAAS,MAAM,EAAE;IAExB,CAEE,UAAU,SAAS,KAAK,SAAS,MAAM,GAAG,OAAO,CAAC,KAAK,CAAC,GAAG,IAAI,CAAC,OAAO,CAAC,EACxE,UAAU,SAAS,aAAa,CAAC,KAAK,EAAE,SAAS,CAAC,OAAO,CAAC,CAAC,EAC3D,KAAK,SAAS,MAAM,EAEpB,KAAK,EAAE,UAAU,SAAS,IAAI,GAAG,KAAK,GAAG,SAAS,CAAC,OAAO,CAAC,GAC1D,gBAAgB,CAAC,KAAK,EAAE,GAAG,EAAE,OAAO,EAAE,WAAW,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC,CAAA;CAC1E;AAED,UAAU,uBAAuB,CAC/B,KAAK,SAAS,EAAE,EAChB,GAAG,EACH,OAAO,SAAS,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,EAC5C,MAAM,SAAS,UAAU,EACzB,MAAM,SAAS,MAAM,OAAO,EAC5B,KAAK,SAAS,MAAM;IAEpB,IAAI,gBAAgB,CAAC,KAAK,EAAE,GAAG,EAAE,OAAO,EAAE,WAAW,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC,CAAA;CACtE;AAED,aAAK,mBAAmB,CACtB,KAAK,SAAS,EAAE,EAChB,GAAG,EACH,OAAO,SAAS,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,EAC5C,MAAM,SAAS,UAAU,EACzB,MAAM,SAAS,MAAM,OAAO,EAC5B,MAAM,SAAS,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC,QAAQ,CAAC,EACjD,OAAO,SAAS,YAAY,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,YAAY,CAAC,MAAM,EAAE,MAAM,CAAC,IACzE,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAC,GAC3B,KAAK,GACL,0BAA0B,CAAC,KAAK,EAAE,GAAG,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,CAAC,GACtE,uBAAuB,CAAC,KAAK,EAAE,GAAG,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC,CAAA;AAEjF,oBAAY,oBAAoB,CAC9B,KAAK,SAAS,EAAE,EAChB,GAAG,EACH,OAAO,SAAS,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,EAC5C,MAAM,SAAS,UAAU,IACvB,WAAW,CAAC;KACb,MAAM,IAAI,MAAM,OAAO,IAAI,SAAS,MAAM,SAAS,MAAM,GACtD,MAAM,GACN,KAAK,EAAE,GAAG,mBAAmB,CAAC,KAAK,EAAE,GAAG,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,CAAC;CACvE,CAAC,CAAA"}

package/dist/types/methods/before.js

@@ -1,7 +0,0 @@
-/**
- * Methods for rewinding a modular component up to a given stage.
- * If multiple entries of the same stage were previously added,
- * it's possible to pass the index for the entry to rewind to.
- */
-export {};
-//# sourceMappingURL=before.js.map

package/dist/types/methods/before.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"before.js","sourceRoot":"","sources":["../../../src/types/methods/before.ts"],"names":[],"mappings":"AAAA;;;;GAIG"}

package/dist/types/methods/hook.d.ts

@@ -1,14 +0,0 @@
-/**
- * Methods for converting a modular component to hooks, either
- * a generic hook returning all the arguments, or a specific hook
- * returning one given argument.
- */
-import { StageTuple } from '../stage';
-import { MethodRecord } from '../methods';
-import { ComputeArguments } from '../arguments';
-export declare type ModularHookMethods<Props extends {}, Ref, Methods extends Record<string, MethodRecord>, Stages extends StageTuple, Arguments extends {} = ComputeArguments<Props, Ref, Methods, Stages>> = {
-    asHook(): keyof Props extends never ? () => Arguments : (props: Props) => Arguments;
-} & {
-    [Arg in keyof Arguments as `asUse${Capitalize<Arg extends string ? Arg : never>}`]: keyof Props extends never ? () => () => Arguments[Arg] : () => (props: Props) => Arguments[Arg];
-};
-//# sourceMappingURL=hook.d.ts.map

package/dist/types/methods/hook.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"hook.d.ts","sourceRoot":"","sources":["../../../src/types/methods/hook.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,UAAU,EAAE,MAAM,UAAU,CAAA;AACrC,OAAO,EAAE,YAAY,EAAE,MAAM,YAAY,CAAA;AACzC,OAAO,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAA;AAE/C,oBAAY,kBAAkB,CAC5B,KAAK,SAAS,EAAE,EAChB,GAAG,EACH,OAAO,SAAS,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,EAC5C,MAAM,SAAS,UAAU,EACzB,SAAS,SAAS,EAAE,GAAG,gBAAgB,CAAC,KAAK,EAAE,GAAG,EAAE,OAAO,EAAE,MAAM,CAAC,IAClE;IACF,MAAM,IAAI,MAAM,KAAK,SAAS,KAAK,GAC/B,MAAM,SAAS,GACf,CAAC,KAAK,EAAE,KAAK,KAAK,SAAS,CAAA;CAChC,GAAG;KACD,GAAG,IAAI,MAAM,SAAS,IAAI,QAAQ,UAAU,CAC3C,GAAG,SAAS,MAAM,GAAG,GAAG,GAAG,KAAK,CACjC,EAAE,GAAG,MAAM,KAAK,SAAS,KAAK,GAC3B,MAAM,MAAM,SAAS,CAAC,GAAG,CAAC,GAC1B,MAAM,CAAC,KAAK,EAAE,KAAK,KAAK,SAAS,CAAC,GAAG,CAAC;CAC3C,CAAA"}

package/dist/types/methods/hook.js

@@ -1,7 +0,0 @@
-/**
- * Methods for converting a modular component to hooks, either
- * a generic hook returning all the arguments, or a specific hook
- * returning one given argument.
- */
-export {};
-//# sourceMappingURL=hook.js.map

package/dist/types/methods/hook.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"hook.js","sourceRoot":"","sources":["../../../src/types/methods/hook.ts"],"names":[],"mappings":"AAAA;;;;GAIG"}