mould/mould.ts at master · mouldjs/mould · GitHub

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
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
import { Cpu, Code } from 'react-feather'
import Components from './components'
import Mould from './components/Mould'
import Kit from './components/Kit'
import Controls from './controls'
import setup from './.mould/setup'
import { AtomicComponent } from './app/types'

type ComponentsByType = {
    [key: string]: AtomicComponent['Raw']
}
type TransformsByType = {
    [key: string]: AtomicComponent['Transform']
}

type AtomicComponentByType = {
    [key: string]: AtomicComponent | undefined
}

const MouldComp = {
    type: 'Mould',
    Editable: Mould,
    Raw: Mould,
    Icon: Cpu,
}

const KitComp = {
    type: 'Kit',
    Editable: Kit,
    Raw: Kit,
    Icon: Code,
}

const MouldInstance = {
    appWrapper: (app) => app,
    Components,
    Controls,
    get transforms() {
        return this.Components.reduce(
            (transformsByType, { type, Transform }) => ({
                ...transformsByType,
                [type]: Transform,
            }),
            {} as TransformsByType
        )
    },
    get components() {
        return this.Components.reduce(
            (componentsByType, { type, Raw, category, Icon }) => {
                componentsByType[type] = {
                    Raw,
                    type,
                    category: category || {
                        name: 'Atomic',
                        isBase: true,
                    },
                    Icon,
                }

                return componentsByType
            },
            {} as ComponentsByType
        )
    },
    get definitions() {
        return this.Components.reduce(
            (atomicComponentsByType, definition) => ({
                ...atomicComponentsByType,
                [definition.type]: definition,
            }),
            {} as AtomicComponentByType
        )
    },
    getComponent(type) {
        switch (type) {
            case 'Mould':
                return MouldComp
            case 'Kit':
                return KitComp
            default:
                return this.Components.find((c) => c.type === type)
        }
    },
    getControl(type) {
        return this.Controls[type]
    },
}

type InsType = typeof MouldInstance

const extensions: InsType = (setup as any)(MouldInstance)
MouldInstance.Components = [
    ...MouldInstance.Components,
    ...(extensions.Components || []),
]
Object.assign(MouldInstance.Controls, extensions.Controls)
MouldInstance.appWrapper = extensions.appWrapper || ((app) => app)

export default MouldInstance