macoolka-type-model
Version:
`macoolka-type-model` is a library for define model in TypeScript. It easily build a type contain field and method to your Application. It provide a generation model for type and validition
314 lines • 12.1 kB
JavaScript
;
var __assign = (this && this.__assign) || function () {
__assign = Object.assign || function(t) {
for (var s, i = 1, n = arguments.length; i < n; i++) {
s = arguments[i];
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
t[p] = s[p];
}
return t;
};
return __assign.apply(this, arguments);
};
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;
};
var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
if (ar || !(i in from)) {
if (!ar) ar = Array.prototype.slice.call(from, 0, i);
ar[i] = from[i];
}
}
return to.concat(ar || Array.prototype.slice.call(from));
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.buildTs = exports.printSchema = exports.printTypeAlias = exports.printInterface = exports.printMethod = exports.getMaybeArrayName = void 0;
var utils_1 = require("./utils");
var constant_1 = require("../constant");
var macoolka_predicate_1 = require("macoolka-predicate");
var O = __importStar(require("fp-ts/Option"));
var pipeable_1 = require("fp-ts/pipeable");
var E = __importStar(require("fp-ts/Either"));
var _a = (0, utils_1.formatCode)({}), formatBlock = _a.formatBlock, formatItem = _a.formatItem, fold = _a.fold;
function intersection(_a) {
var indent = _a.indent;
return function (content) {
return formatBlock({
begin: "",
end: '',
indent: indent,
split: '&',
content: content
});
};
}
function union(_) {
return function (content) {
return content.length === 0 ? 'never' : content.join(' | ');
};
}
/**
* Get a typesciprt type name with model type
*/
var getTypeName = function (option) { return function (a) {
var indent = option.indent, isInput = option.isInput;
if ((0, macoolka_predicate_1.isString)(a)) {
switch (a) {
case 'int':
return 'number';
case 'datetime':
return isInput ? 'string' : 'Date';
case 'json':
return 'Record<string,any>';
default:
return a;
}
}
var typename;
switch (a._kind) {
case 'kind': {
typename = "'".concat(a.value, "'");
break;
}
case 'type':
typename = a.value;
break;
case 'datetime':
typename = isInput ? 'string' : 'Date';
break;
case 'int':
typename = 'number';
break;
case 'json':
typename = 'Record<string,any>';
break;
case 'typeUnion':
typename = union(indent)(a.values.map(function (value) { return "".concat(value); })); // .join(' | ')
break;
case 'typeIntersection':
typename = intersection(option)(a.values.map(function (value) { return "".concat(value); })); // .join(' | ')
break;
case 'enum':
typename = union(indent)(a.values.map(function (value) { return "'".concat(value, "'"); })); // .join(' | ')
break;
default:
typename = a._kind;
}
var maybe = a.maybe, isArray = a.isArray, isArrayRequired = a.isArrayRequired, maybeArray = a.maybeArray;
var arrayname = isArrayRequired === true
? getNotEmptyArrayName(typename)
: isArray === true
? getArrayName(typename)
: maybeArray === true
? (0, exports.getMaybeArrayName)(typename)
: typename;
// getMaybeArrayName
return maybe ? arrayname : getNotRequiredName(arrayname);
}; };
function printTypeReference(option) {
return function (_a) {
var required = _a.required, type = _a.type;
var isInput = option.isInput;
var defaultRequied = ((!(0, macoolka_predicate_1.isString)(type)) && (!(0, macoolka_predicate_1.isMaybe)(type.defaultValue)
|| (type.isArray === true && type.defaultEmptyArray === true)));
required = isInput
? defaultRequied
? false
: required
: defaultRequied
? true
: required;
var typename = getTypeName(option)(type);
return {
required: required,
content: typename
};
};
}
/**
* Get typescript's statement with model field
*
*/
function printField(option) {
return function (field) {
var _a = option.end, end = _a === void 0 ? '' : _a, indent = option.indent, showDesc = option.showDesc;
var name = field.name;
var _b = printTypeReference(option)(field), required = _b.required, content = _b.content;
var body = printNameBody({ name: name, required: required, content: content, end: end });
return formatItem(indent, showDesc)({
content: body,
docs: field
});
};
}
var printNameBody = function (_a) {
var required = _a.required, content = _a.content, name = _a.name, end = _a.end;
var split = (required)
? ': '
: '?: ';
return "".concat(name).concat(split).concat(content).concat(end);
};
var printNameBodyType = function (_a) {
var content = _a.content, name = _a.name, end = _a.end;
return "".concat(name, " = ").concat(content).concat(end);
};
var getArrayName = function (name) { return "Array<".concat(name, ">"); };
var getNotRequiredName = function (name) { return "".concat(name); };
var getNotEmptyArrayName = function (name) { return "NonEmptyArray<".concat(name, ">"); };
var getMaybeArrayName = function (name) { return "MaybeArray<".concat(name, ">"); };
exports.getMaybeArrayName = getMaybeArrayName;
/**
* @since 0.2.0
*/
function printMethod(option) {
return function (input) {
var indent = option.indent, showDesc = option.showDesc;
var type = input.type, name = input.name, _a = input.params, params = _a === void 0 ? [] : _a, returnVoid = input.returnVoid;
var typename = getTypeName(option)(type);
var _type = returnVoid === true ? "void" : typename;
return formatBlock({
begin: formatItem(0, showDesc)({
content: "".concat(name, ":("),
docs: input
}),
end: ") => ".concat(_type),
indent: indent,
content: params.map(printField(__assign(__assign({}, option), { end: ',', indent: indent + 1 })))
});
};
}
exports.printMethod = printMethod;
/**
* get interface implement statement
* @example
* const a=['A','B']
* expect(getImplementsName(a)).toEquals(' extends A,B')
*
* @since 0.2.0
*/
var getImplementsName = function (as) {
return as.length === 0 ?
'' :
"extends ".concat(as.join(', '), " ");
};
/**
* @since 0.2.0
*/
function printInterface(option) {
return function (param) {
var indent = option.indent, showDesc = option.showDesc;
var _a = param.fields, fields = _a === void 0 ? [] : _a, _b = param.methods, methods = _b === void 0 ? [] : _b, name = param.name, _c = param.implements, impl = _c === void 0 ? [] : _c;
// required is ture when id is ture
var rfields = fields.map(function (a) { return (__assign(__assign({}, a), { required: a.id ? a.id : a.required })); });
return formatBlock({
begin: formatItem(indent, showDesc)({
content: "export interface ".concat(name, " ").concat(getImplementsName(impl), "{"),
docs: param
}),
end: '}',
indent: indent,
content: rfields.map(printField(__assign(__assign({}, option), { indent: indent + 1 }))).concat(methods.map(printMethod(__assign(__assign({}, option), { indent: indent + 1 }))))
});
};
}
exports.printInterface = printInterface;
/**
* @since 0.2.0
*/
function printTypeAlias(option) {
return function (typeAlias) {
var indent = option.indent, showDesc = option.showDesc;
var _a = typeAlias.fields, fields = _a === void 0 ? [] : _a, _b = typeAlias.methods, methods = _b === void 0 ? [] : _b, name = typeAlias.name;
var _c = printTypeReference(option)(typeAlias), required = _c.required, content = _c.content;
var fieldContent = fields.map(printField(__assign(__assign({}, option), { indent: indent + 1 })));
var methodContent = methods.map(printMethod(__assign(__assign({}, option), { indent: indent + 1 })));
var body = (fields.length > 0 || methodContent.length > 0)
? O.some(formatBlock({
begin: '{',
end: '}',
indent: indent,
content: fieldContent.concat(methodContent)
}))
: O.none;
var pcontent = (0, pipeable_1.pipe)(body, O.map(function (a) { return intersection(option)([a, content]); }), O.getOrElse(function () { return content; }));
// const pcontent = intersection(indent)([body, content])
return formatItem(indent, showDesc)({
content: "export type ".concat(printNameBodyType({ name: name, required: required, content: pcontent, end: '' })),
docs: typeAlias
});
};
}
exports.printTypeAlias = printTypeAlias;
/**
* @since 0.2.0
*/
function printSchema(option) {
return function (input) {
var indent = option.indent, showDesc = option.showDesc;
var interfaces = input.interfaces, typealiases = input.typealiases;
return formatBlock({
begin: formatItem(indent, showDesc)({
content: "",
docs: input
}),
end: '',
indent: indent,
content: __spreadArray(__spreadArray([], typealiases.map(printTypeAlias(option)), true), interfaces.map(printInterface(option)), true)
});
};
}
exports.printSchema = printSchema;
/**
* TSBuild instance
* @since 0.2.0
*/
var buildTs = function (option) {
if (option === void 0) { option = {}; }
return function (schema) {
var _a = option.header, header = _a === void 0 ? constant_1.headerTS : _a, _b = option.imports, imports = _b === void 0 ? constant_1.importsTS : _b, showDesc = option.showDesc;
var indent = 0;
var content = formatBlock({
begin: formatItem(indent, showDesc)({
content: fold(imports),
docs: {
description: header,
deprecated: false,
ignore: false,
examples: [],
reason: [],
path: [],
help: [],
since: '0.2.0'
}
}),
end: '',
indent: indent,
content: [printSchema(__assign({ indent: indent }, option))(schema)]
});
return E.right(content);
};
};
exports.buildTs = buildTs;
exports.default = exports.buildTs;
//# sourceMappingURL=TypeBuild.js.map