@lcap/nasl
Version:
NetEase Application Specific Language
278 lines • 12.5 kB
JavaScript
;
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
var desc = Object.getOwnPropertyDescriptor(m, k);
if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
desc = { enumerable: true, get: function() { return m[k]; } };
}
Object.defineProperty(o, k2, desc);
}) : (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
o["default"] = v;
});
var __importStar = (this && this.__importStar) || function (mod) {
if (mod && mod.__esModule) return mod;
var result = {};
if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
__setModuleDefault(result, mod);
return result;
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.createEleLogins = exports.getAllComponentEventMap = exports.elementsEventsMap = void 0;
const concepts_1 = require("../concepts");
const utils = __importStar(require("../utils"));
const event_1 = require("./event");
exports.elementsEventsMap = {};
function getAllComponentEventMap(allComponent) {
const eventsMap = {};
for (const i in allComponent) {
const item = allComponent[i];
if (item.events && Array.isArray(item.events)) {
item.events.forEach((eventItem) => {
const name = `${item.name}-${eventItem.name}`;
eventsMap[name] = eventItem;
});
}
}
event_1.trigger.forEach((item) => {
eventsMap[item.name] = item;
});
// elementsEventsMap = eventsMap;
Object.assign(exports.elementsEventsMap, eventsMap);
return eventsMap;
}
exports.getAllComponentEventMap = getAllComponentEventMap;
const toHump = (name) => (name ? name.replace(/\-(\w)/g, (all, letter) => letter.toUpperCase()) : '');
function formatUiTs(allComponent) {
const indent = (tabSize) => ' '.repeat(tabSize * 2);
const toNaslType = (type) => {
if (type === 'number')
return 'nasl.core.Long';
if (type === 'string')
return 'nasl.core.String';
if (type === 'boolean')
return 'nasl.core.Boolean';
if (type === 'Array<string>')
return 'nasl.collection.List<nasl.core.String>';
return type;
};
const createDefault = (param) => {
const defaultValue = param.default;
if (defaultValue) {
if (typeof defaultValue === 'number') {
return new concepts_1.NumericLiteral({ value: `${defaultValue}` });
}
if (typeof defaultValue === 'boolean') {
return new concepts_1.BooleanLiteral({ value: `${defaultValue}` });
}
if (typeof defaultValue === 'string' && !defaultValue.includes('.')) {
return new concepts_1.StringLiteral({ value: defaultValue });
}
return null;
}
return null;
};
const createMethodLogic = (method) => {
const { name, params } = method;
const logic = new concepts_1.Logic({
name,
params: params.map((param) => {
let required = true;
if (param.required === false) {
required = false;
}
let typeAnnotation = null;
const { name, type } = param;
if (param.typeAnnotation !== undefined)
typeAnnotation = concepts_1.TypeAnnotation.createProtoTypeOnly(param.typeAnnotation);
else if (type === 'number')
typeAnnotation = concepts_1.TypeAnnotation.createPrimitiveProtoTypeOnly({ typeName: 'Long' });
else if (type === 'string')
typeAnnotation = concepts_1.TypeAnnotation.createPrimitiveProtoTypeOnly({ typeName: 'String' });
else if (type === 'boolean')
typeAnnotation = concepts_1.TypeAnnotation.createPrimitiveProtoTypeOnly({ typeName: 'Boolean' });
else if (type === 'Array<string>')
typeAnnotation = concepts_1.TypeAnnotation.createProtoTypeOnly({
typeName: 'List',
typeKind: 'generic',
typeArguments: [concepts_1.TypeAnnotation.createProtoTypeOnly({ typeName: 'String' })],
});
else {
typeAnnotation = concepts_1.TypeAnnotation.createPrimitiveProtoTypeOnly({ typeName: 'any' });
}
return new concepts_1.Param({
name,
typeAnnotation,
defaultExpression: createDefault(param),
defaultValue: param.defaultValue,
});
}),
});
return logic;
};
const elementsLogic = {};
let value = `declare namespace nasl.ui {\n`;
for (const i in allComponent) {
const item = allComponent[i];
const componentName = utils.kebab2Pascal(item.name);
if (!componentName)
continue;
const hasDataSource = item.attrs && item.attrs.find((item) => ['dataSource', 'data-source'].includes(item.name));
const typeParams = hasDataSource ? '<T>' : '';
// console.log(item);
value += `export class ${componentName}${typeParams} extends ViewComponent{
constructor(options?: Partial<${componentName}Options${typeParams}>)`;
// 生成methods
if (Object.prototype.toString.call(item.methods) === '[object Array]') {
const logics = [];
item.methods.forEach((method) => {
if (!method.advanced) {
const methodName = `${method.name}`;
// 有参数
if (Array.isArray(method.params) && method.params.length) {
let methodParamStr = '';
method.params.forEach((param) => {
methodParamStr += param.name.includes('?') ? `${param.name}: ` : `${param.name}?: `;
const type = toNaslType(param.type);
methodParamStr += type;
methodParamStr += ',';
});
value += indent(1);
value += `${methodName}: (${methodParamStr}) => any;\n`;
logics.push(createMethodLogic(method));
}
else {
value += indent(1);
value += `${methodName}: () => any;\n`;
logics.push(createMethodLogic({ name: methodName, params: [] }));
}
}
});
elementsLogic[componentName] = logics;
}
value += `}`;
value += `class ${componentName}Options${typeParams} extends ViewComponentOptions {\n`;
// 生成属性
if (Object.prototype.toString.call(item.attrs) === '[object Array]') {
item.attrs.forEach((attr) => {
const { name } = attr;
if (['dataSource', 'data-source'].includes(name)) {
value += indent(1);
value += `'${utils.kebab2Camel2(name)}': nasl.collection.List<T> | { total: nasl.core.Integer, list: nasl.collection.List<T> };\n`;
}
else if (name === 'sorting') {
value += indent(1);
value += `'${utils.kebab2Camel2(name)}': {
field: nasl.core.String
order: nasl.core.String
};\n`;
}
else if (name === 'value') {
value += indent(1);
value += `'${utils.kebab2Camel2(name)}': any;\n`;
}
else if (attr.type === 'number') {
value += indent(1);
value += `'${utils.kebab2Camel2(name)}': nasl.core.Long;\n`;
}
else if (attr.type === 'Array') {
value += indent(1);
value += `'${utils.kebab2Camel2(name)}': Array<any>;\n`;
}
else {
value += indent(1);
value += `${utils.kebab2Camel2(name)}: any;\n`;
}
});
value += indent(1);
value += `[prop: string]: any;\n`;
}
// 生成slot
// tableview先写死其余slot没有声明类型的 都先放默认的
if (Object.prototype.toString.call(item.slots) === '[object Array]') {
item.slots.forEach((slot) => {
const slotName = toHump(`slot-${slot.name}`);
// 如果已经有带参数的slotDefault
if (slotName === 'slotDefault') {
if (slot.supportGenericComponents && slot.supportGenericComponents.length) {
let str = '';
slot.supportGenericComponents.forEach((componentName) => {
const name = utils.kebab2Pascal(componentName);
str += `Array<${name}<T>> | `;
});
// 没有插槽的
value += `slotDefault?: () => ${str} Array<any>;\n`;
}
else if (slot.slotProps) {
const typeAnnotation = concepts_1.TypeAnnotation.createProtoTypeOnly(slot.slotProps.typeAnnotation);
value += `slotDefault?: (current: ${typeAnnotation.typeKey}) => Array<any>;\n`;
}
else if (item.attrs && item.attrs.find((item) => item.name === 'dataSource')) {
// 没有插槽的
value += `slotDefault?: (current: nasl.ui.Current<T>)=> Array<any>;\n`;
}
else {
// 没有插槽的
value += `slotDefault?: ()=> Array<any>;\n`;
}
}
else if (!slot.advanced) {
if (slot.slotProps) {
const typeAnnotation = concepts_1.TypeAnnotation.createProtoTypeOnly(slot.slotProps.typeAnnotation);
value += `${slotName}?: (current: ${typeAnnotation.typeKey}) => Array<any>;\n`;
}
else {
value += `${slotName}?: () => Array<any>;\n`;
}
}
});
}
else {
// 没有插槽的
value += `slotDefault?: () => Array<any>;\n`;
}
value += `};\n`;
}
value += '}\n';
return {
code: value,
elementsLogic,
elementsEventsMap: exports.elementsEventsMap,
};
}
exports.default = formatUiTs;
function createEleLogins(components) {
const map = {};
// eslint-disable-next-line no-restricted-syntax, guard-for-in
for (const i in components) {
const componentName = utils.kebab2Pascal(i);
if (Object.prototype.hasOwnProperty.call(components, i)) {
const item = components[i];
const logics = [];
if (item.methods?.length) {
item.methods.forEach((method) => {
const { name, params } = method;
logics.push(new concepts_1.Logic({
name,
params: params?.map((param) => {
return new concepts_1.Param({
name: param.name,
typeAnnotation: concepts_1.TypeAnnotation.createProtoTypeOnly(param.typeAnnotation),
defaultValue: param.defaultValue,
});
}) || [],
}));
});
}
map[componentName] = logics;
}
}
return map;
}
exports.createEleLogins = createEleLogins;
//# sourceMappingURL=createUiTs.js.map