@jsmanifest/content-combiner
Version:
Combine content from multiple sources and transform them into one unified data structure to work with
237 lines (222 loc) • 8.24 kB
JavaScript
;
Object.defineProperty(exports, '__esModule', { value: true });
/*! *****************************************************************************
Copyright (c) Microsoft Corporation.
Permission to use, copy, modify, and/or distribute this software for any
purpose with or without fee is hereby granted.
THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
PERFORMANCE OF THIS SOFTWARE.
***************************************************************************** */
function __awaiter(thisArg, _arguments, P, generator) {
function adopt(value) {
return value instanceof P ? value : new P(function (resolve) {
resolve(value);
});
}
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) : adopt(result.value).then(fulfilled, rejected);
}
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
}
function __classPrivateFieldGet(receiver, privateMap) {
if (!privateMap.has(receiver)) {
throw new TypeError("attempted to get private field on non-instance");
}
return privateMap.get(receiver);
}
function __classPrivateFieldSet(receiver, privateMap, value) {
if (!privateMap.has(receiver)) {
throw new TypeError("attempted to set private field on non-instance");
}
privateMap.set(receiver, value);
return value;
}
const entries = (o) => Object.entries(o);
const isArr = (val) => Array.isArray(val);
const isObj = (v) => !!v && typeof v === 'object';
const isStr = (v) => !!v && typeof v === 'string';
const isFnc = (v) => typeof v === 'function';
const get = (obj, path) => {
if (typeof path !== 'string' && !isArr(path))
return undefined;
let result = obj;
let parts = isArr(path) ? path.slice() : path.split('.');
let totalParts = parts.length;
if (isObj(result)) {
for (let index = 0; index < totalParts; index++) {
const key = parts[index];
if (isStr(key))
result = result && result[key];
}
}
return result;
};
class Keymapper {
constructor() {
this.keymap = new Map();
}
/**
* Uses the key to retrieve the mapped value, which is used on the obj
* @param { string } key
*/
parse(mapper, obj) {
if (arguments.length < 2) {
throw new Error('Missing mapper or data object');
}
let result;
if (obj) {
if (isStr(mapper) || isArr(mapper)) {
result = get(obj, mapper);
}
else if (isFnc(mapper)) {
result = mapper(obj);
}
else {
result = get(obj, isStr(mapper) ? mapper : String(mapper));
}
}
else {
throw new TypeError('Argument "obj" is null or undefined');
}
return result;
}
get(key) {
return this.keymap.get(key);
}
/**
* Sets the mapper into the keymap by the key
* @param { string } key
*/
set(key, mapper) {
this.keymap.set(key, mapper);
return this;
}
}
var _keymapper, _fetchers, _dataKeys, _createId;
class PostsAggregator {
constructor({ dataKeys = [], fetchers = [], keymapper, } = {}) {
_keymapper.set(this, new Keymapper());
_fetchers.set(this, void 0);
_dataKeys.set(this, []);
_createId.set(this, () => {
return `_${Math.random().toString(36).substr(2, 9)}`;
});
__classPrivateFieldSet(this, _fetchers, fetchers);
__classPrivateFieldSet(this, _keymapper, keymapper && keymapper instanceof Keymapper ? keymapper : new Keymapper());
this.setDataKeys(dataKeys);
}
/**
* Runs each fetcher and parses each list of results using the keymappers that
* are currently registered
* @param { object } options - Options passed to each fetch function
*/
execute(options) {
return __awaiter(this, void 0, void 0, function* () {
let results = [];
const numFetchers = __classPrivateFieldGet(this, _fetchers).length;
for (let index = 0; index < numFetchers; index++) {
const fetch = __classPrivateFieldGet(this, _fetchers)[index];
const result = yield fetch(options);
if (result) {
if (isArr(result)) {
results = results.concat(result);
}
else {
results.push([result]);
}
}
}
return results;
});
}
createFetcher(fetch, options) {
const parseDataObject = (dataObject, keymappers) => entries(keymappers).reduce((acc, [key, mapper]) => {
acc[key] = __classPrivateFieldGet(this, _keymapper).parse(mapper, dataObject);
return acc;
}, {});
let err;
// prettier-ignore
if (!isFnc(fetch))
err = new Error('The fetch function provided as the first argument is not a function');
if (!options.keymappers)
err = new TypeError('keymappers is not an object');
if (err)
throw err;
const fetcher = (...args) => __awaiter(this, void 0, void 0, function* () {
const result = yield fetch(...args);
if (!result)
return result;
return isArr(result)
? result.reduce((acc, item) => item ? acc.concat(parseDataObject(item, options.keymappers)) : acc, [])
: parseDataObject(result, options.keymappers);
});
fetcher.id = __classPrivateFieldGet(this, _createId).call(this);
__classPrivateFieldGet(this, _fetchers).push(fetcher);
return fetcher;
}
/** Formats/parses the keymappers and returns the keymap used on the executor */
getKeymap() {
return Array.from(new Set(Array.from(__classPrivateFieldGet(this, _keymapper).keymap.keys()).concat(this.getDataKeys()))).reduce((acc, key) => {
const mapper = __classPrivateFieldGet(this, _keymapper).get(key);
if (isStr(mapper) || isArr(mapper)) {
// Mapped directly by property swapping
acc[key] = (item) => __classPrivateFieldGet(this, _keymapper).parse(mapper, item);
}
else if (isFnc(mapper)) {
// Function mapper
acc[key] = mapper;
}
else {
// Default mapper (the key itself)
acc[key] = (item) => __classPrivateFieldGet(this, _keymapper).parse(key, item);
}
return acc;
}, {});
}
getKeymapper(key) {
return __classPrivateFieldGet(this, _keymapper).get(key);
}
setKeymapper(key, mapper) {
if (isStr(key)) {
__classPrivateFieldGet(this, _keymapper).set(key, mapper);
}
else if (isObj(key)) {
entries(key).forEach(([k, v]) => {
__classPrivateFieldGet(this, _keymapper).set(k, v);
});
}
return this;
}
getDataKeys() {
return __classPrivateFieldGet(this, _dataKeys);
}
setDataKeys(keys) {
__classPrivateFieldSet(this, _dataKeys, keys);
return this;
}
}
_keymapper = new WeakMap(), _fetchers = new WeakMap(), _dataKeys = new WeakMap(), _createId = new WeakMap();
exports.Keymapper = Keymapper;
exports.default = PostsAggregator;
//# sourceMappingURL=index.js.map