All files / src declare.ts

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
3x
3x
3x
 
 
3x
 
 
6x
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
3x
3x
 
 
 
 
 
 
6x
6x
9x
 
 
 
 
5x
 
 
 
 
 
 
 
3x
 
4x
 
 
 
 
import { ElementOf, Narrow, transform } from "@re-do/utils"
import { parse } from "./parse.js"
import { CompileFunction, createCompileFunction } from "./compile.js"
import { TypeSet } from "./components"
 
export const createDefineFunctionMap = <DeclaredTypeNames extends string[]>(
    typeNames: DeclaredTypeNames
) =>
    transform(typeNames, ([i, typeName]) => [
        typeName as string,
        createDefineFunction(typeNames, typeName as any)
    ]) as DefineFunctionMap<DeclaredTypeNames>
 
export type DefineFunctionMap<DeclaredTypeNames extends string[]> = {
    [DefinedTypeName in ElementOf<DeclaredTypeNames>]: DefineFunction<
        DefinedTypeName,
        DeclaredTypeNames
    >
}
 
export type DefineFunction<
    DefinedTypeName extends ElementOf<DeclaredTypeNames>,
    DeclaredTypeNames extends string[]
> = <Def>(
    definition: TypeSet.ValidateReferences<
        Narrow<Def>,
        ElementOf<DeclaredTypeNames>
    >
) => {
    [K in DefinedTypeName]: Def
}
 
export const createDefineFunction =
    <
        DefinedTypeName extends ElementOf<DeclaredTypeNames>,
        DeclaredTypeNames extends string[]
    >(
        declaredTypeNames: DeclaredTypeNames,
        definedTypeName: DefinedTypeName
    ): DefineFunction<DefinedTypeName, DeclaredTypeNames> =>
    (definition: any) => {
        parse(definition, {
            typeSet: transform(declaredTypeNames, ([i, typeName]) => [
                typeName,
                "unknown"
            ]) as any
        })
        return { [definedTypeName]: definition } as any
    }
 
export type Declaration<DeclaredTypeNames extends string[] = string[]> = {
    define: DefineFunctionMap<DeclaredTypeNames>
    compile: CompileFunction<DeclaredTypeNames>
}
 
export const declare = <DeclaredTypeNames extends string[]>(
    ...names: Narrow<DeclaredTypeNames>
) => ({
    define: createDefineFunctionMap(names),
    compile: createCompileFunction(names)
})