metaf-react
Version:
Resolvable component and injection root for adding DI/IoC to React App
164 lines • 7.52 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 __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
}) : (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 __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;
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.overrides = exports.resolveRequirements = exports.resolver = exports.ReactResolver = exports.overrideRequirement = void 0;
// import { observe } from 'metaf-observable';
var MetafResolvable = __importStar(require("metaf-resolvable"));
var metaf_resolvable_1 = require("metaf-resolvable");
var requirementsOverride = Symbol('Requirements Override');
/**
* Function that meant to be used as only way for specifying requirements overrides
* it's designed to provide best possible type safety, but until something like this:
* https://github.com/Microsoft/TypeScript/issues/13890
* will land to TSX type inference, it only forces users to replace requirement HOC
* by another HOC, which, obviously, could ignore initial invariants,
* but unfortunately there are no better options for now
* @description creates a `[key, value]` pair describing requirement override
* @template T type of requirement key that has to be overwritten
* @template R type of value that will be used instead of original requirement
* @param key actual key that has to be overwritten
* @param value value that will be passed as requirement for this `key`
* @returns object with symbol property which point to `[key, value]` pair
*/
function overrideRequirement(key, value) {
var _a;
return _a = {}, _a[requirementsOverride] = [key, value], _a;
}
exports.overrideRequirement = overrideRequirement;
/**
* @internal
*/
var ReactResolver = /** @class */ (function (_super) {
__extends(ReactResolver, _super);
function ReactResolver() {
var _this = _super !== null && _super.apply(this, arguments) || this;
_this.requirements = new Map();
_this.requirementsArray = [];
_this.requirementsSubscribers = [];
return _this;
}
ReactResolver.prototype.setOverrides = function (overrides) {
overrides.forEach(this.setOverride.bind(this));
};
ReactResolver.prototype.setRequirementsOverrides = function (overrides) {
var _this = this;
overrides.forEach(function (requirementPair) {
var _a = __read(requirementPair[requirementsOverride], 2), key = _a[0], value = _a[1];
var prevValue = _this.requirements.get(key);
if (prevValue) {
var index = _this.requirementsArray.indexOf(value);
_this.requirementsArray.splice(index, 1);
}
if (_this.requirementsArray.indexOf(value) === -1) {
_this.requirementsArray.push(value);
}
_this.requirements.set(key, value);
});
};
ReactResolver.prototype.resolveRequirements = function (requirements, classImpl) {
var _this = this;
var isRequirementsUpdated = false;
requirements
.forEach(function (requirement) {
if (_this.requirements.has(requirement))
return;
_this.requirements.set(requirement, requirement);
_this.requirementsArray.push(requirement);
isRequirementsUpdated = true;
});
if (isRequirementsUpdated)
this.requirementsSubscribers.forEach(function (subscriber) { return subscriber(_this.requirementsArray); });
return _super.prototype.resolveRequirements.call(this, requirements, classImpl);
};
ReactResolver.prototype.subscribeForRequirements = function (subscriber) {
this.requirementsSubscribers.push(subscriber);
return this.requirementsArray;
};
ReactResolver.prototype.initialize = function (obj) {
var result = _super.prototype.initialize.call(this, obj);
return (typeof result === 'object' && result !== null)
? /* synchronous */ ( /* observe */(result))
: result;
};
return ReactResolver;
}(MetafResolvable.Resolver));
exports.ReactResolver = ReactResolver;
/**
* @internal
*/
exports.resolver = new ReactResolver();
/**
* Entry point for resolving requirements for particular `ResolvableComponent`,
* but also could be used as a HOC for any other component including `SFC`s
* @description resolves `requirements` for `componentImpl` and applies them to `ApplicationRoot`
* @template R type of `requirements` tuple
* @template C type of `componentImpl`
* @param requirements tuple of specific requirements that should be met by hosting application
* @param componentImpl particular resolvable class implementation
* @returns exactly same `componentImpl`, but with resolved requirements
*/
function resolveRequirements(requirements, componentImpl) {
return exports.resolver.resolveRequirements(requirements, componentImpl);
}
exports.resolveRequirements = resolveRequirements;
function resolveFor(classImpl, injections, instance, args) {
if (injections === void 0) { injections = {}; }
return exports.resolver.resolveFor(classImpl, injections, instance, args);
}
MetafResolvable.setResolverFn(resolveFor, resolveRequirements);
exports.overrides = {
set: function (key, value) {
exports.resolver.setOverrides([(0, metaf_resolvable_1.override)(key, value)]);
return exports.overrides;
}
};
//# sourceMappingURL=Resolver.js.map