FilesExpand file tree

 main

/

index.ts

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

70 lines (64 loc) · 2.05 KB

 main

/

index.ts

Copy path

Top

File metadata and controls

• Code
• Blame

70 lines (64 loc) · 2.05 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

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

import 'ts-polyfill';

import { remove, lstatSync } from 'fs-extra';

import { join, isAbsolute } from 'path';

import {

IMaterializeOptions,

IMaterializeLocalOptions,

IMaterializeOnlineOptions,

IInternalMaterializeOptions,

} from './types';

import { ComponentMeta } from './core';

import scan from './scan';

import generate from './generate';

import parse from './parse';

import localize from './localize';

export { default as validate } from './validate';

export { default as schema } from './validate/schema.json';

export * from './types';

export default async function (options: IMaterializeOptions): Promise<ComponentMeta[]> {

const { accesser = 'local', dslType } = options;

let { entry = '' } = options;

const internalOptions: IInternalMaterializeOptions = {

...options,

accesser,

entry: options.entry || '',

root: (options as IMaterializeLocalOptions)?.root || '',

} as IInternalMaterializeOptions;

if (accesser === 'local') {

const { root } = options as IMaterializeLocalOptions;

internalOptions.root = root;

if (!root) {

const stats = lstatSync(entry);

if (stats.isDirectory()) {

internalOptions.root = entry;

} else {

internalOptions.root = process.cwd();

}

} else if (!isAbsolute(entry)) {

internalOptions.entry = join(root, entry);

}

}

let workDir = internalOptions.root || '';

let moduleDir = '';

if (accesser === 'online') {

const result = await localize(internalOptions as IMaterializeOnlineOptions);

workDir = result.workDir;

moduleDir = result.moduleDir;

internalOptions.entry = result.entry ? join(moduleDir, result.entry) : moduleDir;

internalOptions.root = moduleDir;

}

const scanedModel = await scan(internalOptions);

const parsedModel = await parse({

...scanedModel,

dslType,

accesser,

npmClient: internalOptions.npmClient,

workDir,

moduleDir,

});

const result = await generate(scanedModel, parsedModel, internalOptions);

if (workDir && accesser === 'online') {

await remove(workDir);

}

return result;

}