@lcap/builder/lib/utils/schema-utils.js

lcap builder utils

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.genMethodCode = exports.genSlotCode = exports.genEventCode = exports.genAttrCode = exports.genSetterCode = exports.genTypeCode = exports.genTitle = exports.normalizeSlotName = exports.normalizeEventName = exports.normalizeString = void 0;
const lodash_1 = require("lodash");
const eventRegex = /^on[A-Z].*/;
const slotRegex = /^slot[A-Z].*/;
function normalizeString(str) {
    return str ? str.replace(/'/g, '\\\'') : '';
}
exports.normalizeString = normalizeString;
function normalizeEventName(name) {
    if (eventRegex.test(name)) {
        return name;
    }
    return `on${(0, lodash_1.upperFirst)(name)}`;
}
exports.normalizeEventName = normalizeEventName;
function normalizeSlotName(name) {
    if (slotRegex.test(name) || name.startsWith('slot-')) {
        return name;
    }
    return name.includes('-') ? `slot-${name}` : `slot${(0, lodash_1.upperFirst)(name)}`;
}
exports.normalizeSlotName = normalizeSlotName;
function genTitle(name, title) {
    if (title) {
        return title;
    }
    return (0, lodash_1.kebabCase)(name).split('-').map((word) => (0, lodash_1.upperFirst)(word)).join(' ');
}
exports.genTitle = genTitle;
function genTypeCode(type) {
    if ((0, lodash_1.isNil)(type)) {
        return 'any';
    }
    if (typeof type !== 'object') {
        return type;
    }
    if (type.type === 'string') {
        return 'nasl.core.String';
    }
    if (type.type === 'number') {
        return 'nasl.core.Integer | nasl.core.Decimal';
    }
    if (type.type === 'boolean') {
        return 'nasl.core.Boolean';
    }
    if (type.type === 'array') {
        return `nasl.collection.List<${type.value ? genTypeCode(type.value) : 'any'}>`;
    }
    if (type.type === 'struct') {
        if (!type.value || type.value.length === 0) {
            return '{}';
        }
        return `{
      ${type.value.map((item) => `${item.name}: ${genTypeCode(item.type)},`).join(' ')}
    }`;
    }
    if (type.type === 'map') {
        return `nasl.collection.Map<nasl.core.String, ${genTypeCode(type.value)}>`;
    }
    if (type.type === 'union') {
        return `(${(type.value || []).map((item) => genTypeCode(item)).join(' | ')})`;
    }
    if (type.type === 'function') {
        return `(${(type.params || []).map((item) => `${item.name}: ${genTypeCode(item.type)}`).join(', ')}) => ${genTypeCode(type.returnType)}`;
    }
    return 'any';
}
exports.genTypeCode = genTypeCode;
function genSetterCode(attr) {
    const { type, options } = attr;
    if (options && options.length > 0) {
        return `setter: {
      concept: 'EnumSelectSetter',
      options: ${JSON.stringify(options.map((option) => ({ title: option.label })))},
    },`;
    }
    if (type.type === 'number') {
        return `setter: {
      concept: 'NumberInputSetter',
    },`;
    }
    if (type.type === 'boolean') {
        return `setter: {
      concept: 'SwitchSetter',
    },`;
    }
    return `setter: {
    concept: 'InputSetter',
  },`;
}
exports.genSetterCode = genSetterCode;
function genAttrCode(attr, group = '主要属性') {
    const { name, description, type, defaultValue, sync, } = attr;
    const title = genTitle(name);
    const propOptions = [
        `group: '${group}',`,
        `title: '${title}',`,
        `description: '${normalizeString(description || title)}',`,
        genSetterCode(attr),
    ];
    if (sync) {
        propOptions.push('sync: true,');
    }
    return `
    @Prop({
      ${propOptions.join('\n')}
    })
    ${name}: ${genTypeCode(type)}${defaultValue ? ` = ${defaultValue}` : ''};
  `;
}
exports.genAttrCode = genAttrCode;
function genEventCode(event) {
    let { name } = event;
    name = normalizeEventName(name);
    const title = genTitle(name);
    return `
  @Event({
    title: '${title}',
    description: '${normalizeString(event.description || title)}',
  })
  ${name}: (event: {}) => any;
`;
}
exports.genEventCode = genEventCode;
function genSlotCode(slot) {
    let { name } = slot;
    name = normalizeSlotName(name);
    const title = genTitle(name);
    return `
  @Slot({
    title: '${title}',
    description: '${normalizeString(slot.description || title)}',
  })
  ${name.includes('-') ? `'${name}'` : name}: () => Array<nasl.ui.ViewComponent>;
`;
}
exports.genSlotCode = genSlotCode;
function genMethodCode(method) {
    const { name, description, params, returnType, } = method;
    const title = genTitle(name);
    return `
  @Method({
    title: '${title}',
    description: '${normalizeString(description || title)}',
  })
  ${name}(${params.map((param) => `${param.name}: ${genTypeCode(param.type)}`).join(', ')}): ${returnType ? genTypeCode(returnType) : 'void'} {
    ${returnType ? 'return null as any;' : ''}
  }
`;
}
exports.genMethodCode = genMethodCode;