metaf-react
Version:
Resolvable component and injection root for adding DI/IoC to React App
96 lines • 4.14 kB
JavaScript
;
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
if (typeof b !== "function" && b !== null)
throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
var __read = (this && this.__read) || function (o, n) {
var m = typeof Symbol === "function" && o[Symbol.iterator];
if (!m) return o;
var i = m.call(o), r, ar = [], e;
try {
while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
}
catch (error) { e = { error: error }; }
finally {
try {
if (r && !r.done && (m = i["return"])) m.call(i);
}
finally { if (e) throw e.error; }
}
return ar;
};
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));
};
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.ResolvableComponent = exports.Component = void 0;
// import { autorun, observe } from 'metaf-observable';
var metaf_resolvable_1 = require("metaf-resolvable");
// import { context, PromiseCache } from 'metaf-sync';
var react_1 = __importDefault(require("react"));
var ReactComponent = (0, metaf_resolvable_1.Resolvable)(react_1.default.Component);
/**
* @description Component factory
*/
exports.Component = (function (injections) {
var requirements = [];
for (var _i = 1; _i < arguments.length; _i++) {
requirements[_i - 1] = arguments[_i];
}
var BaseComponent = /** @class */ (function (_super) {
__extends(BaseComponent, _super);
function BaseComponent(props) {
return _super.call(this, props) || this;
// -----------------------------------------------
// Previous code for suspended and reactive render
// -----------------------------------------------
// const originalRender = this.render.bind(this);
// const rerun = this.forceUpdate.bind(this);
// const render = autorun(originalRender, {
// rerun,
// });
// this.render = () => {
// try {
// return render();
// } catch (err) {
// if (!(err instanceof PromiseCache)) throw err;
// err.resolved
// .then(() => rerun(() => context.cache = new WeakMap()))
// .catch(innerError => { throw innerError; });
// // TODO: think about null return in render
// // tslint:disable-next-line: no-null-keyword
// return null;
// }
// };
// return observe(this);
// -----------------------------------------------
}
return BaseComponent;
}(ReactComponent.apply(void 0, __spreadArray([injections], __read(requirements), false))));
return BaseComponent;
});
/**
* @deprecated please, use `Component` instead
*/
exports.ResolvableComponent = exports.Component;
//# sourceMappingURL=Component.js.map