dts-element-fp
Version:
typescript definition generator for functional programming
155 lines (154 loc) • 8.28 kB
JavaScript
;
var __assign = (this && this.__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;
};
exports.__esModule = true;
var dts = require("dts-element");
var R = require("ramda");
var constants_1 = require("./utils/constants");
var create_masks_1 = require("./utils/create-masks");
var create_selectable_signatures_1 = require("./utils/create-selectable-signatures");
var get_generics_dependencies_1 = require("./utils/get-generics-dependencies");
var has_1 = require("./utils/has");
var push_signatures_1 = require("./utils/push-signatures");
/**
* @hidden
*/
function create_curried_types(name, type, options) {
// istanbul ignore next
var $options = options !== undefined ? options : {};
// istanbul ignore next
var _a = $options.selectable, selectable = _a === void 0 ? constants_1.selectable_default : _a, _b = $options.placeholder, placeholder = _b === void 0 ? constants_1.placeholder_default : _b, _c = $options.get_placeholder_type, get_placeholder_type = _c === void 0 ? constants_1.get_placeholder_type_default : _c, _d = $options.get_function_type_name, get_function_type_name = _d === void 0 ? constants_1.get_function_type_name_default : _d, _e = $options.get_function_parameter_placeholder_name, get_function_parameter_placeholder_name = _e === void 0 ? constants_1.get_function_parameter_placeholder_name_default : _e, get_selectable_kind_name = $options.get_selectable_kind_name, get_selectable_selector_name = $options.get_selectable_selector_name, _f = $options.inline_return_type, inline_return_type = _f === void 0 ? constants_1.inline_return_type_default : _f;
var is_placeholder = function (value) {
return dts.is_general_type(value) && value.name === get_placeholder_type();
};
// istanbul ignore next
var _g = type.generics, generics = _g === void 0 ? [] : _g, _h = type.parameters, parameters = _h === void 0 ? [] : _h, return_type = type["return"];
var type_predicate_parameter = dts.is_type_predicate(return_type)
? parameters.find(function (parameter) { return parameter.name === return_type.parameter; })
: null;
var placeholders = parameters.map(function (parameter) {
return dts.create_parameter_declaration({
name: get_function_parameter_placeholder_name(parameter.name),
type: dts.create_general_type({ name: get_placeholder_type() })
});
});
var generics_dependencies = get_generics_dependencies_1.get_generics_dependencies(generics);
var sort_generics = function (the_generics) {
return the_generics
.slice()
.sort(function (a, b) { return generics.indexOf(a) - generics.indexOf(b); });
};
var add_generic_dependencies = function (the_generics) {
var added = [];
the_generics.forEach(function (generic) {
added.push.apply(added, generics_dependencies[generics.indexOf(generic)]);
});
return sort_generics(R.uniq(added));
};
var parameters_generics = parameters.map(function (parameter) {
return add_generic_dependencies(generics.filter(function (generic) {
return has_1.has(parameter, {
kind: dts.ElementKind.GeneralType,
name: generic.name
});
}));
});
var return_generics = add_generic_dependencies(generics.filter(function (generic) {
return has_1.has(return_type, {
kind: dts.ElementKind.GeneralType,
name: generic.name
});
}));
var target_types = R.repeat(0, Math.pow(2, parameters.length)).map(function (_, index, array) {
return index === array.length - 1
? dts.is_type_predicate(return_type)
? dts.boolean_type
: return_type
: dts.create_object_type({ members: [] });
});
var masks = create_masks_1.create_masks(parameters.length);
var reverse_masks = masks.reduce(function (current_reverse_masks, mask, index) {
return (__assign({}, current_reverse_masks, (_a = {}, _a[mask] = index, _a)));
var _a;
}, {});
var type_declarations = target_types.map(function (target_type, index) {
var type_generics = sort_generics(index === target_types.length - 1
? return_generics
: parameters_generics
.filter(function (_, generics_index) { return masks[index][generics_index] === '1'; })
.reduce(function (current_type_generics, filtered_parameter_generics) {
return R.uniq(current_type_generics.concat(filtered_parameter_generics));
}, []));
return dts.create_type_declaration({
name: get_function_type_name(name, masks[index]),
generics: type_generics,
type: target_type
});
});
type_declarations.slice(0, -1).forEach(function (type_declaration, index) {
var members = type_declaration.type
.members;
push_signatures_1.push_signatures(is_placeholder, parameters.filter(function (_, param_index) { return masks[index][param_index] === '0'; }), placeholder
? placeholders.filter(function (_, param_index) { return masks[index][param_index] === '0'; })
: [], function (used_parameters, return_parameters) {
var return_mask = parameters
.map(function (parameter) {
return return_parameters.indexOf(parameter) === -1 ? '1' : '0';
})
.join('');
var return_type_declaration = type_declarations[reverse_masks[return_mask]];
var return_type_generics = return_type_declaration.generics.map(function (generic) { return dts.create_general_type({ name: generic.name }); });
var used_parameters_generics = sort_generics(R.uniq(used_parameters.reduce(function (current, parameter) { return current.concat((function (parameter_index) {
return parameter_index === -1
? []
: parameters_generics[parameter_index];
})(parameters.indexOf(parameter))); }, return_type_declaration.generics))).filter(function (generic) { return type_declaration.generics.indexOf(generic) === -1; });
members.push(dts.create_object_member({
owned: dts.create_function_declaration({
name: undefined,
type: dts.create_function_type({
generics: used_parameters_generics,
parameters: used_parameters,
"return": get_overload_return_type()
})
})
}));
function get_overload_return_type() {
if (return_mask.split('').every(R.equals('1'))) {
if (type_predicate_parameter !== null) {
if (used_parameters.indexOf(type_predicate_parameter) !== -1) {
return return_type; // type_predicate: value is Type (matched parameter)
}
if (inline_return_type) {
return dts.boolean_type; // type_predicate: boolean (unmatched parameter)
}
}
else if (inline_return_type) {
return return_type;
}
}
return dts.create_general_type({
name: return_type_declaration.name,
generics: return_type_generics
});
}
});
if (!selectable || members.length <= 1) {
return;
}
members.splice.apply(members, [-1,
0].concat(create_selectable_signatures_1.create_selectable_signatures(members, {
is_placeholder: is_placeholder,
get_selectable_kind_name: get_selectable_kind_name,
get_selectable_selector_name: get_selectable_selector_name
})));
});
return type_declarations;
}
exports.create_curried_types = create_curried_types;