fractal-core
Version:
A minimalist and well crafted app, content or component is our conviction
228 lines • 8.43 kB
JavaScript
;
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
return new (P || (P = Promise))(function (resolve, reject) {
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
};
Object.defineProperty(exports, "__esModule", { value: true });
const module_1 = require("./module");
const input_1 = require("./input");
exports.makeInterfaceHelpers = (ctx) => ({
ctx,
interfaceOf: exports._interfaceOf(ctx),
stateOf: input_1._stateOf(ctx),
in: exports._in(ctx),
act: exports._act(ctx),
inFn: exports._inFn(ctx),
actFn: exports._actFn(ctx),
vw: exports._vw(ctx),
vws: exports._vws(ctx),
group: exports._group(ctx),
});
// gets an interface message from a certain component
exports._interfaceOf = (ctx) => (name, interfaceName) => __awaiter(this, void 0, void 0, function* () {
let id = `${ctx.id}$${name}`;
let compCtx = ctx.components[id];
if (!compCtx) {
ctx.error('interfaceOf', `there are no component space '${id}'`);
return {};
}
if (!compCtx.interfaces[interfaceName]) {
ctx.error('interfaceOf', `there are no interface '${interfaceName}' in component '${compCtx.name}' from space '${id}'`);
return {};
}
// search in interface cache
let cache = compCtx.interfaceValues[interfaceName];
if (cache) {
return cache;
}
else {
// caches interface
compCtx.interfaceValues[interfaceName]
= yield compCtx.interfaces[interfaceName](compCtx.state, compCtx.interfaceHelpers);
return compCtx.interfaceValues[interfaceName];
}
});
// create an InputData array
exports._in = (ctx) => (inputName, context, param, options) => {
return [ctx.id, inputName, context, param, options];
};
// generic action dispatcher
exports._act = (ctx) => {
let _inCtx = exports._in(ctx);
return (actionName, context, param, options) => _inCtx('_action', [actionName, context], param, options);
};
// create an InputData array
exports._inFn = (ctx) => {
const dispatchCtx = exports.dispatch(ctx);
return (inputName, context, param, options) => {
return (event) => exports.invokeHandler(ctx.error, dispatchCtx, [ctx.id, inputName, context, param, options], event);
};
};
// generic action dispatcher
exports._actFn = (ctx) => {
let _inFnCtx = exports._inFn(ctx);
return (actionName, context, param, options) => _inFnCtx('_action', [actionName, context], param, options);
};
// extract component view interface, sintax sugar
exports._vw = (ctx) => {
let _interfaceOfCtx = exports._interfaceOf(ctx);
return (componentName) => __awaiter(this, void 0, void 0, function* () { return yield _interfaceOfCtx(componentName, 'view'); });
};
// extract view interfaces based on component names
exports._vws = (ctx) => {
let _interfaceOfCtx = exports._interfaceOf(ctx);
return (names) => __awaiter(this, void 0, void 0, function* () {
let views = [];
for (let i = 0, len = names.length; i < len; i++) {
views.push(yield _interfaceOfCtx(names[i], 'view'));
}
return views;
});
};
// extract view interfaces from a component group
exports._group = (ctx) => {
let _interfaceOfCtx = exports._interfaceOf(ctx);
let comps = input_1._componentHelpers(ctx);
return (groupName) => __awaiter(this, void 0, void 0, function* () {
let views = [];
let componentNames = comps(groupName).getCompleteNames();
for (let i = 0, len = componentNames.length; i < len; i++) {
views.push(yield _interfaceOfCtx(componentNames[i], 'view'));
}
return views;
});
};
/**
* Extract a path or some paths from an Event Object
* @param path An array that contains an object path
* @param event An Event Object
*/
function computePath(path, event) {
let data;
let actual = event;
for (let i = 0, len = path.length; i < len; i++) {
if (path[i] instanceof Array) {
data = {};
let keys = path[i];
for (let i = 0, len = keys.length; i < len; i++) {
data[keys[i]] = actual[keys[i]];
}
}
else {
actual = actual[path[i]];
}
}
if (!data) {
data = actual;
}
return data;
}
function computeEvent(eventData, iData) {
let data;
let haveContext = iData[2] !== undefined;
let haveParam = iData[3] !== undefined;
if (iData[3] === '*') {
// serialize the whole object (note that DOM events are not serializable, use paths instead)
data = JSON.parse(JSON.stringify(eventData));
}
else if (iData[3] !== undefined) {
// have fetch parameter
if (iData[3] instanceof Array) {
// fetch parameter is a path, e.g. ['target', 'value']
let param = iData[3];
if (param[1] && param[1] instanceof Array) {
data = [];
for (let i = 0, len = param.length; i < len; i++) {
data[i] = computePath(param[i], eventData);
}
}
else {
// only one path
data = computePath(param, eventData);
}
}
else {
// fetch parameter is only a getter, e.g. 'target'
data = eventData[iData[3]];
}
}
if (!haveContext && !haveParam) {
return [iData[0], iData[1]]; // dispatch an input with no arguments
}
return [
iData[0],
iData[1],
haveContext && haveParam
? [iData[2], data]
: haveParam
? data
: iData[2]
];
}
exports.computeEvent = computeEvent;
exports.dispatchEv = (ctx) => (event, iData) => __awaiter(this, void 0, void 0, function* () {
let compCtx = ctx.components[iData[0] + ''];
if (!compCtx) {
ctx.error('Dispatch Event (dispatchEv)', `There is no component with id: ${iData[0]}`);
return;
}
let cInputData = computeEvent(event, iData);
return yield module_1.toIn(compCtx)(cInputData[1], cInputData[2]);
});
exports.dispatch = (ctx) => (eventData) => __awaiter(this, void 0, void 0, function* () {
let compCtx = ctx.components[eventData[0] + ''];
if (!compCtx) {
ctx.error('Dispatch EventData (dispatch)', `There is no component with id: ${eventData[0]}`);
return;
}
return yield module_1.toIn(compCtx)(eventData[1], eventData[2]);
});
/**
* toComp function factory
* @param ctx
* @returns CtxToComp
*/
exports.toComp = (ctx) => (id, inputName, data) => __awaiter(this, void 0, void 0, function* () {
let compCtx = ctx.components[id];
if (!compCtx) {
ctx.error('Execute component input (toComp)', `There is no component with id: ${id}`);
return;
}
return yield module_1.toIn(compCtx)(inputName, data);
});
exports.invokeHandler = (error, dispatchCtx, handler, event) => {
if (handler instanceof Array && typeof handler[0] === 'string') {
let options = handler[4];
if ((options && options.listenPrevented !== true || !options) && event.defaultPrevented) {
return;
}
if (options && options.default === false) {
event.preventDefault();
}
setImmediate(() => {
dispatchCtx(computeEvent(event, handler));
});
}
else if (handler instanceof Array) {
// call multiple handlers
for (var i = 0; i < handler.length; i++) {
exports.invokeHandler(error, dispatchCtx, handler[i], event);
}
}
else if (handler === 'ignore') {
// this handler is ignored
event.preventDefault();
}
else if (handler === '' && handler === undefined) {
// this handler is passed
return;
}
else {
error('Interface helpers - invokeHandler', 'event handler of type ' + typeof handler + 'are not allowed, data: ' + JSON.stringify(handler));
}
};
//# sourceMappingURL=interface.js.map