@lcap/builder
Version:
lcap builder utils
264 lines (263 loc) • 9.91 kB
JavaScript
;
Object.defineProperty(exports, "__esModule", { value: true });
exports.addTypeMap = exports.transformDefaultValue = void 0;
const lodash_1 = require("lodash");
const babel_utils_1 = require("../utils/babel-utils");
function transformTSTypeReference(node) {
var _a, _b, _c;
const code = (0, babel_utils_1.getNodeCode)(node);
switch (true) {
case code.startsWith('nasl.core.String'):
return {
type: 'string',
};
case code.startsWith('nasl.core.Integer'):
return {
type: 'integer',
};
case code.startsWith('nasl.core.Decimal'):
return {
type: 'decimal',
};
case code.startsWith('nasl.core.Boolean'):
return {
type: 'boolean',
};
case code.startsWith('nasl.core.DateTime'):
return {
type: 'datetime',
};
case code.startsWith('nasl.core.Date'):
return {
type: 'date',
};
case code.startsWith('nasl.core.Time'):
return {
type: 'time',
};
case code.startsWith('nasl.collection.List'):
return {
type: 'array',
value: ((_a = node.typeParameters) === null || _a === void 0 ? void 0 : _a.params[0]) ? transformTsType2NType(node.typeParameters.params[0]) : { type: 'any' },
};
case code.startsWith('nasl.collection.Map'):
return {
type: 'map',
key: ((_b = node.typeParameters) === null || _b === void 0 ? void 0 : _b.params[0]) ? transformTsType2NType(node.typeParameters.params[0]) : { type: 'any' },
value: ((_c = node.typeParameters) === null || _c === void 0 ? void 0 : _c.params[1]) ? transformTsType2NType(node.typeParameters.params[1]) : { type: 'any' },
};
default:
return {
type: 'unknow',
raw: code,
};
}
}
function transformTsType2NType(typeAST) {
switch (typeAST.type) {
case 'TSTypeReference':
return transformTSTypeReference(typeAST);
case 'TSStringKeyword':
return {
type: 'string',
};
case 'TSNumberKeyword':
return {
type: 'union',
value: [
{
type: 'integer',
},
{
type: 'decimal',
},
],
};
case 'TSBooleanKeyword':
return {
type: 'boolean',
};
case 'TSAnyKeyword':
return {
type: 'any',
};
case 'TSUnionType':
return {
type: 'union',
value: typeAST.types.map((item) => transformTsType2NType(item)),
};
case 'TSFunctionType':
return {
type: 'function',
params: (typeAST.parameters || []).map((item, index) => {
switch (item.type) {
case 'Identifier':
return {
name: item.name,
type: item.typeAnnotation && item.typeAnnotation.type === 'TSTypeAnnotation' ? transformTsType2NType(item.typeAnnotation.typeAnnotation) : { type: 'any' },
};
default:
return {
name: `params${index}`,
type: {
type: 'any',
},
};
}
}),
returnType: (typeAST.typeAnnotation
&& typeAST.typeAnnotation.type === 'TSTypeAnnotation'
&& typeAST.typeAnnotation.typeAnnotation.type !== 'TSVoidKeyword') ? transformTsType2NType(typeAST.typeAnnotation.typeAnnotation) : 'void',
};
case 'TSTypeLiteral':
return {
type: 'struct',
value: typeAST.members.map((item, index) => {
switch (item.type) {
case 'TSPropertySignature':
return {
name: item.key.type === 'Identifier' ? item.key.name : `property${index}`,
type: item.typeAnnotation && item.typeAnnotation.type === 'TSTypeAnnotation' ? transformTsType2NType(item.typeAnnotation.typeAnnotation) : { type: 'any' },
};
default:
return {
name: `property${index}`,
type: {
type: 'any',
},
};
}
}),
};
default:
return {
type: 'unknow',
raw: (0, babel_utils_1.getNodeCode)(typeAST),
};
}
}
function resolvePropTsType(prop) {
if (!prop.tsType) {
return {
type: 'any',
};
}
const typeAST = (0, babel_utils_1.getTypeAST)(prop.tsType);
return transformTsType2NType(typeAST);
}
function resolveEventTsType(event) {
var _a;
if (!event.tsType) {
return {
type: 'struct',
value: [],
};
}
const typeAST = (0, babel_utils_1.getTypeAST)(event.tsType);
if (typeAST.type !== 'TSFunctionType'
|| !typeAST.parameters[0]
|| typeAST.parameters[0].type !== 'Identifier'
|| ((_a = typeAST.parameters[0].typeAnnotation) === null || _a === void 0 ? void 0 : _a.type) !== 'TSTypeAnnotation') {
return {
type: 'struct',
value: [],
};
}
return transformTsType2NType(typeAST.parameters[0].typeAnnotation.typeAnnotation);
}
function resolveSlotTsType(slot) {
var _a;
if (!slot.tsType) {
return null;
}
const typeAST = (0, babel_utils_1.getTypeAST)(slot.tsType);
if (typeAST.type !== 'TSFunctionType'
|| !typeAST.parameters[0]
|| typeAST.parameters[0].type !== 'Identifier'
|| ((_a = typeAST.parameters[0].typeAnnotation) === null || _a === void 0 ? void 0 : _a.type) !== 'TSTypeAnnotation') {
return null;
}
return transformTsType2NType(typeAST.parameters[0].typeAnnotation.typeAnnotation);
}
function transformDefaultValue(defaultValue) {
var _a;
if (!(defaultValue === null || defaultValue === void 0 ? void 0 : defaultValue.expression)) {
return '';
}
switch ((_a = defaultValue.expression) === null || _a === void 0 ? void 0 : _a.concept) {
case 'NullLiteral':
return 'null';
case 'BooleanLiteral':
return defaultValue.expression.value;
case 'StringLiteral':
return `'${defaultValue.expression.value}'`;
case 'NumericLiteral':
return defaultValue.expression.value;
case 'NewList':
return `[${defaultValue.expression.items.map((item) => transformDefaultValue({ expression: item })).filter((v) => !(0, lodash_1.isNil)(v)).join(', ')}]`;
default:
return '';
}
}
exports.transformDefaultValue = transformDefaultValue;
function resolveMethodTsType(method) {
var _a;
if (!method.tsType) {
return {
params: [],
returnType: 'void',
};
}
const typeAST = (0, babel_utils_1.getTypeAST)(method.tsType);
if (typeAST.type !== 'TSFunctionType') {
return {
params: [],
returnType: 'void',
};
}
return {
params: method.params.map((param, index) => {
let paramType = null;
if (typeAST.parameters[index]
&& typeAST.parameters[index].type === 'Identifier'
&& typeAST.parameters[index].typeAnnotation
&& typeAST.parameters[index].typeAnnotation.type === 'TSTypeAnnotation') {
paramType = typeAST.parameters[index].typeAnnotation.typeAnnotation;
}
return {
name: param.name,
type: paramType ? transformTsType2NType(paramType) : { type: 'any' },
description: param.description,
defaultValue: transformDefaultValue(param.defaultValue),
};
}),
returnType: (((_a = typeAST.typeAnnotation) === null || _a === void 0 ? void 0 : _a.type) === 'TSTypeAnnotation'
&& typeAST.typeAnnotation.typeAnnotation.type !== 'TSVoidKeyword') ? transformTsType2NType(typeAST.typeAnnotation.typeAnnotation) : 'void',
};
}
function addTypeMap(component) {
const typeMap = {
prop: {},
event: {},
slot: {},
method: {},
readableProp: {},
};
component.props.forEach((prop) => {
typeMap.prop[prop.name] = resolvePropTsType(prop);
});
component.events.forEach((event) => {
typeMap.event[event.name] = resolveEventTsType(event);
});
component.slots.forEach((slot) => {
typeMap.slot[slot.name] = resolveSlotTsType(slot);
});
component.readableProps.forEach((readableProp) => {
typeMap.readableProp[readableProp.name] = resolvePropTsType(readableProp);
});
component.methods.forEach((method) => {
typeMap.method[method.name] = resolveMethodTsType(method);
});
return Object.assign(Object.assign({}, component), { typeMap, children: (component.children || []).map((n) => addTypeMap(n)) });
}
exports.addTypeMap = addTypeMap;