163 | )
164 | }
165 | }
166 |
167 | // Here we inject `user` service and its state.
168 | // Remove andState, if you only need the service.
169 | export default withService('user', andState())(Home)
170 | ```
171 |
172 | ## License
173 |
174 | MIT
175 |
176 |
--------------------------------------------------------------------------------
/src/index.js:
--------------------------------------------------------------------------------
1 | import React from 'react'
2 | import { connect, Provider } from 'react-redux'
3 | import BaseBuilder from 'jservice'
4 | import ServiceCollection from './collection'
5 | import ServiceProvider from './provider'
6 |
7 | // Built-in services
8 | import UtilService from './services/util'
9 | import StorageService from './services/storage'
10 | import StoreService from './services/store'
11 |
12 | // DI container contexts
13 | const ContainerContext = React.createContext()
14 | const AsyncCountContext = React.createContext(0)
15 |
16 | class ReactServices extends BaseBuilder {
17 |
18 | constructor() {
19 | super()
20 | this.collection = new ServiceCollection(this)
21 | this.provider = new ServiceProvider(this.collection)
22 | }
23 |
24 | createProvider() {
25 | throw new Error('Scoped providers are not supported yet')
26 | }
27 |
28 | }
29 |
30 | function createContainer() {
31 | return new ReactServices()
32 | .build(services => {
33 | services.add(UtilService)
34 | services.add(StorageService)
35 | services.add(StoreService)
36 | })
37 | }
38 |
39 | function mapStateToProps(serviceNames, state) {
40 | return serviceNames.reduce((result, name) => {
41 | const val = state[name]
42 | if (val) result[name] = val
43 | return result
44 | }, {})
45 | }
46 |
47 | export function withContainer(registry) {
48 | return function (ChildComponent) {
49 | return class extends React.Component {
50 | constructor(props) {
51 | super(props)
52 | this.state = { count: 0 }
53 | this.container = createContainer().build(registry)
54 | this.container.start().then(() => this.forceUpdate())
55 | this.contextValue = {
56 | container: this.container,
57 | asyncLoaded: () => {
58 | this.setState({ count: this.state.count + 1 })
59 | }
60 | }
61 | }
62 | render() {
63 | const store = this.container.provider.service('store').getStore()
64 | const childElement = React.createElement(ChildComponent, {
65 | container: this.container,
66 | ...this.props
67 | })
68 | return React.createElement(
69 | ContainerContext.Provider,
70 | { value: this.contextValue },
71 | React.createElement(
72 | AsyncCountContext.Provider,
73 | { value: this.state.count },
74 | !store ? childElement :
75 | React.createElement(
76 | Provider,
77 | { store },
78 | childElement
79 | ))
80 | )
81 | }
82 | }
83 | }
84 | }
85 |
86 | export function withNewService(registry) {
87 | return function (ChildComponent) {
88 | return function (props) {
89 | return React.createElement(ContainerContext.Consumer, null,
90 | function (context) {
91 | context.container.build(registry)
92 | return React.createElement(
93 | ChildComponent,
94 | { container: context.container },
95 | props.children
96 | )
97 | }
98 | )
99 | }
100 | }
101 | }
102 |
103 | export function withService(...serviceNames) {
104 | return function (ChildComponent) {
105 | if (Array.isArray(serviceNames[serviceNames.length - 1])) {
106 | const states = serviceNames.pop()
107 | ChildComponent = withState.apply(null,
108 | states.length ? states : serviceNames)(ChildComponent)
109 | }
110 | return function (props) {
111 | return React.createElement(ContainerContext.Consumer, null,
112 | function (context) {
113 | return React.createElement(AsyncCountContext.Consumer, null,
114 | function () {
115 | return React.createElement(ChildComponent, {
116 | services: context.container.provider.createServices(
117 | serviceNames,
118 | context.asyncLoaded
119 | ),
120 | ...props
121 | })
122 | }
123 | )
124 | }
125 | )
126 | }
127 | }
128 | }
129 |
130 | export function withState(...serviceNames) {
131 | return function (ChildComponent) {
132 | if (Array.isArray(serviceNames[serviceNames.length - 1])) {
133 | const services = serviceNames.pop()
134 | ChildComponent = withService.apply(null,
135 | services.length ? services : serviceNames)(ChildComponent)
136 | }
137 | return connect(
138 | state => ({
139 | state: typeof serviceNames[0] === 'function' ?
140 | serviceNames[0](state) :
141 | mapStateToProps(serviceNames, state)
142 | })
143 | )(ChildComponent)
144 | }
145 | }
146 |
147 | export function and(...serviceNames) {
148 | return Array.isArray(serviceNames[0]) ? serviceNames[0] : serviceNames
149 | }
150 |
151 | export {
152 | // HOC
153 | createContainer,
154 | and as andService,
155 | and as andState,
156 | // Services
157 | StorageService,
158 | StoreService,
159 | UtilService
160 | }
161 |
--------------------------------------------------------------------------------
/sample/basic/src/serviceWorker.js:
--------------------------------------------------------------------------------
1 | // This optional code is used to register a service worker.
2 | // register() is not called by default.
3 |
4 | // This lets the app load faster on subsequent visits in production, and gives
5 | // it offline capabilities. However, it also means that developers (and users)
6 | // will only see deployed updates on subsequent visits to a page, after all the
7 | // existing tabs open on the page have been closed, since previously cached
8 | // resources are updated in the background.
9 |
10 | // To learn more about the benefits of this model and instructions on how to
11 | // opt-in, read https://bit.ly/CRA-PWA
12 |
13 | const isLocalhost = Boolean(
14 | window.location.hostname === 'localhost' ||
15 | // [::1] is the IPv6 localhost address.
16 | window.location.hostname === '[::1]' ||
17 | // 127.0.0.1/8 is considered localhost for IPv4.
18 | window.location.hostname.match(
19 | /^127(?:\.(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)){3}$/
20 | )
21 | );
22 |
23 | export function register(config) {
24 | if (process.env.NODE_ENV === 'production' && 'serviceWorker' in navigator) {
25 | // The URL constructor is available in all browsers that support SW.
26 | const publicUrl = new URL(process.env.PUBLIC_URL, window.location.href);
27 | if (publicUrl.origin !== window.location.origin) {
28 | // Our service worker won't work if PUBLIC_URL is on a different origin
29 | // from what our page is served on. This might happen if a CDN is used to
30 | // serve assets; see https://github.com/facebook/create-react-app/issues/2374
31 | return;
32 | }
33 |
34 | window.addEventListener('load', () => {
35 | const swUrl = `${process.env.PUBLIC_URL}/service-worker.js`;
36 |
37 | if (isLocalhost) {
38 | // This is running on localhost. Let's check if a service worker still exists or not.
39 | checkValidServiceWorker(swUrl, config);
40 |
41 | // Add some additional logging to localhost, pointing developers to the
42 | // service worker/PWA documentation.
43 | navigator.serviceWorker.ready.then(() => {
44 | console.log(
45 | 'This web app is being served cache-first by a service ' +
46 | 'worker. To learn more, visit https://bit.ly/CRA-PWA'
47 | );
48 | });
49 | } else {
50 | // Is not localhost. Just register service worker
51 | registerValidSW(swUrl, config);
52 | }
53 | });
54 | }
55 | }
56 |
57 | function registerValidSW(swUrl, config) {
58 | navigator.serviceWorker
59 | .register(swUrl)
60 | .then(registration => {
61 | registration.onupdatefound = () => {
62 | const installingWorker = registration.installing;
63 | if (installingWorker == null) {
64 | return;
65 | }
66 | installingWorker.onstatechange = () => {
67 | if (installingWorker.state === 'installed') {
68 | if (navigator.serviceWorker.controller) {
69 | // At this point, the updated precached content has been fetched,
70 | // but the previous service worker will still serve the older
71 | // content until all client tabs are closed.
72 | console.log(
73 | 'New content is available and will be used when all ' +
74 | 'tabs for this page are closed. See https://bit.ly/CRA-PWA.'
75 | );
76 |
77 | // Execute callback
78 | if (config && config.onUpdate) {
79 | config.onUpdate(registration);
80 | }
81 | } else {
82 | // At this point, everything has been precached.
83 | // It's the perfect time to display a
84 | // "Content is cached for offline use." message.
85 | console.log('Content is cached for offline use.');
86 |
87 | // Execute callback
88 | if (config && config.onSuccess) {
89 | config.onSuccess(registration);
90 | }
91 | }
92 | }
93 | };
94 | };
95 | })
96 | .catch(error => {
97 | console.error('Error during service worker registration:', error);
98 | });
99 | }
100 |
101 | function checkValidServiceWorker(swUrl, config) {
102 | // Check if the service worker can be found. If it can't reload the page.
103 | fetch(swUrl)
104 | .then(response => {
105 | // Ensure service worker exists, and that we really are getting a JS file.
106 | const contentType = response.headers.get('content-type');
107 | if (
108 | response.status === 404 ||
109 | (contentType != null && contentType.indexOf('javascript') === -1)
110 | ) {
111 | // No service worker found. Probably a different app. Reload the page.
112 | navigator.serviceWorker.ready.then(registration => {
113 | registration.unregister().then(() => {
114 | window.location.reload();
115 | });
116 | });
117 | } else {
118 | // Service worker found. Proceed as normal.
119 | registerValidSW(swUrl, config);
120 | }
121 | })
122 | .catch(() => {
123 | console.log(
124 | 'No internet connection found. App is running in offline mode.'
125 | );
126 | });
127 | }
128 |
129 | export function unregister() {
130 | if ('serviceWorker' in navigator) {
131 | navigator.serviceWorker.ready.then(registration => {
132 | registration.unregister();
133 | });
134 | }
135 | }
136 |
--------------------------------------------------------------------------------
/sample/basic/src/reser/collection.js:
--------------------------------------------------------------------------------
1 | "use strict";
2 |
3 | Object.defineProperty(exports, "__esModule", {
4 | value: true
5 | });
6 | exports["default"] = void 0;
7 |
8 | var _jservice = require("jservice");
9 |
10 | var _proto = require("./services/util/proto");
11 |
12 | var _loader = _interopRequireDefault(require("./loader"));
13 |
14 | function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
15 |
16 | function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
17 |
18 | function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
19 |
20 | function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
21 |
22 | function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
23 |
24 | function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
25 |
26 | function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
27 |
28 | function _get(target, property, receiver) { if (typeof Reflect !== "undefined" && Reflect.get) { _get = Reflect.get; } else { _get = function _get(target, property, receiver) { var base = _superPropBase(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(receiver); } return desc.value; }; } return _get(target, property, receiver || target); }
29 |
30 | function _superPropBase(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf(object); if (object === null) break; } return object; }
31 |
32 | function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
33 |
34 | function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
35 |
36 | function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
37 |
38 | var ServiceCollection =
39 | /*#__PURE__*/
40 | function (_BaseServiceCollectio) {
41 | _inherits(ServiceCollection, _BaseServiceCollectio);
42 |
43 | function ServiceCollection(core) {
44 | var _this;
45 |
46 | _classCallCheck(this, ServiceCollection);
47 |
48 | _this = _possibleConstructorReturn(this, _getPrototypeOf(ServiceCollection).call(this, core));
49 | _this._core = core;
50 | return _this;
51 | }
52 |
53 | _createClass(ServiceCollection, [{
54 | key: "_validate",
55 | value: function _validate(service) {
56 | var err = null;
57 | if (service.async) err = 'async'; // Add more static validation
58 |
59 | if (err) throw new Error("Invalid service signature \"".concat(err, "\""));
60 | }
61 | }, {
62 | key: "_push",
63 | value: function _push(Service, name, config, skip) {
64 | this._validate(Service); // Check if service is async or not
65 |
66 |
67 | if ((0, _proto.isFunction)(Service) && !(0, _proto.isConstructor)(Service)) {
68 | // Async service
69 | Service.service = name;
70 | var loader = new _loader["default"](this._core.provider, Service, name, config);
71 |
72 | var LoaderService = function LoaderService() {
73 | return loader;
74 | };
75 |
76 | LoaderService.type = Service.type;
77 | LoaderService.service = name;
78 | LoaderService.async = true;
79 | Service = LoaderService;
80 | }
81 |
82 | _get(_getPrototypeOf(ServiceCollection.prototype), "_push", this).call(this, Service, name, config, skip);
83 | }
84 | }, {
85 | key: "isAsyncService",
86 | value: function isAsyncService(name) {
87 | var names = this.names,
88 | services = this.services;
89 |
90 | for (var key in names) {
91 | if (names.hasOwnProperty(key) && key === name) {
92 | return services[names[key]].async || false;
93 | }
94 | }
95 |
96 | return true;
97 | }
98 | }, {
99 | key: "scoped",
100 | value: function scoped() {
101 | throw new Error('Scoped services are not supported yet');
102 | }
103 | }, {
104 | key: "transient",
105 | value: function transient() {
106 | throw new Error('Transient services are not supported yet');
107 | }
108 | }]);
109 |
110 | return ServiceCollection;
111 | }(_jservice.ServiceCollection);
112 |
113 | var _default = ServiceCollection;
114 | exports["default"] = _default;
--------------------------------------------------------------------------------
/sample/basic/src/reser/services/store.js:
--------------------------------------------------------------------------------
1 | "use strict";
2 |
3 | Object.defineProperty(exports, "__esModule", {
4 | value: true
5 | });
6 | exports["default"] = void 0;
7 |
8 | var _redux = require("redux");
9 |
10 | function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { keys.push.apply(keys, Object.getOwnPropertySymbols(object)); } if (enumerableOnly) keys = keys.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); return keys; }
11 |
12 | function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(source, true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
13 |
14 | function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
15 |
16 | function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
17 |
18 | function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
19 |
20 | function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
21 |
22 | var Store =
23 | /*#__PURE__*/
24 | function () {
25 | function Store(provider, config) {
26 | _classCallCheck(this, Store);
27 |
28 | _defineProperty(this, "base", null);
29 |
30 | _defineProperty(this, "_namespace", 'rsrx:');
31 |
32 | _defineProperty(this, "_collection", null);
33 |
34 | _defineProperty(this, "_config", null);
35 |
36 | _defineProperty(this, "_reducers", null);
37 |
38 | _defineProperty(this, "_storage", null);
39 |
40 | _defineProperty(this, "_util", null);
41 |
42 | this._config = config;
43 | this._storage = provider.service('storage');
44 | this._util = provider.service('util');
45 | this._collection = provider.service('__core__').collection;
46 | var _this$_collection = this._collection,
47 | names = _this$_collection.names,
48 | services = _this$_collection.services;
49 | var reducers = {};
50 |
51 | for (var name in names) {
52 | if (names.hasOwnProperty(name)) {
53 | var service = services[names[name]];
54 | if (service.reducer) reducers[name] = service.reducer;
55 | }
56 | }
57 |
58 | this._reducers = reducers;
59 | }
60 |
61 | _createClass(Store, [{
62 | key: "_defaultConfig",
63 | value: function _defaultConfig(arg) {
64 | return {
65 | store: (0, _redux.createStore)(arg.rootReducer || function (s) {
66 | return s;
67 | }, arg.initialState || {})
68 | };
69 | }
70 | }, {
71 | key: "_getInitialState",
72 | value: function _getInitialState() {
73 | var _this = this;
74 |
75 | var state = {};
76 | var storage = this._storage;
77 |
78 | if (storage) {
79 | return storage.getAllKeys().then(function (keys) {
80 | var toGet = [];
81 | keys.sort(function (a, b) {
82 | return a.length - b.length;
83 | });
84 | keys.forEach(function (key) {
85 | if (!key.startsWith(_this._namespace)) return;
86 | var path = key.split(':')[1]; // Async service should not be added in initial state
87 |
88 | toGet.push(storage.getItem(key).then(function (value) {
89 | _this._util.set(state, path, JSON.parse(value));
90 | }));
91 | });
92 | return Promise.all(toGet);
93 | }).then(function () {
94 | return state;
95 | });
96 | }
97 |
98 | return Promise.resolve({});
99 | }
100 | }, {
101 | key: "_createStore",
102 | value: function _createStore() {
103 | var _this2 = this;
104 |
105 | return Promise.resolve().then(function () {
106 | return _this2._getInitialState();
107 | }).then(function (state) {
108 | var arg = {
109 | rootReducer: (0, _redux.combineReducers)(_this2._reducers),
110 | initialState: state
111 | };
112 | var result = typeof _this2._config === 'function' ? _this2._config(arg) : _this2._defaultConfig(arg);
113 |
114 | _this2._setStore(result.store);
115 | });
116 | }
117 | }, {
118 | key: "_setStore",
119 | value: function _setStore(store) {
120 | this.base = store;
121 | var _this$_collection2 = this._collection,
122 | names = _this$_collection2.names,
123 | services = _this$_collection2.services;
124 |
125 | for (var name in names) {
126 | if (!names.hasOwnProperty(name)) continue;
127 | var service = services[names[name]];
128 |
129 | if (service.persist) {
130 | this._persistService(service, name);
131 | }
132 | }
133 | }
134 | }, {
135 | key: "_persistService",
136 | value: function _persistService(service, name) {
137 | var _this3 = this;
138 |
139 | if (service.persist === undefined) return;
140 | if (!name) throw new Error('Persistent service must have name'); // Write to storage
141 |
142 | if (service.persist === true) {
143 | // Persist whole service
144 | this._persistState(name);
145 | } else {
146 | // Should be array, persist by keys
147 | service.persist.forEach(function (path) {
148 | _this3._persistState(name + '.' + path);
149 | });
150 | } // Mutate reducer
151 |
152 |
153 | this.base.replaceReducer((0, _redux.combineReducers)(_objectSpread({}, this._reducers, _defineProperty({}, name, service.reducer))));
154 | }
155 | }, {
156 | key: "_persistState",
157 | value: function _persistState(path) {
158 | var _this4 = this;
159 |
160 | var lastState;
161 | var storage = this._storage;
162 | var get = this._util.get;
163 |
164 | var handleChange = function handleChange() {
165 | var currentState = get(_this4.base.getState(), path);
166 |
167 | if (currentState !== lastState) {
168 | lastState = currentState; // Write to storage
169 |
170 | if (storage && path) storage.setItem(_this4._namespace + path, JSON.stringify(currentState));
171 | }
172 | };
173 |
174 | var unsubscribe = this.base.subscribe(handleChange);
175 | handleChange();
176 | return unsubscribe;
177 | }
178 | }, {
179 | key: "getStore",
180 | value: function getStore() {
181 | return this.base;
182 | }
183 | }, {
184 | key: "getState",
185 | value: function getState() {
186 | return this.base.getState();
187 | }
188 | }, {
189 | key: "dispatch",
190 | value: function dispatch(action) {
191 | return this.base.dispatch(action);
192 | }
193 | }, {
194 | key: "replaceReducer",
195 | value: function replaceReducer(nextReducer) {
196 | return this.base.replaceReducer(nextReducer);
197 | }
198 | }, {
199 | key: "subscribe",
200 | value: function subscribe(listener) {
201 | return this.base.subscribe(listener);
202 | }
203 | }], [{
204 | key: "start",
205 | value: function start(provider) {
206 | var store = provider.service('store');
207 | return store._createStore();
208 | }
209 | }]);
210 |
211 | return Store;
212 | }();
213 |
214 | exports["default"] = Store;
215 |
216 | _defineProperty(Store, "service", 'store');
--------------------------------------------------------------------------------
/sample/basic/src/reser/index.js:
--------------------------------------------------------------------------------
1 | "use strict";
2 |
3 | Object.defineProperty(exports, "__esModule", {
4 | value: true
5 | });
6 | exports.withContainer = withContainer;
7 | exports.withNewService = withNewService;
8 | exports.withService = withService;
9 | exports.withState = withState;
10 | exports.andState = exports.andService = exports.and = and;
11 | exports.createContainer = createContainer;
12 | Object.defineProperty(exports, "UtilService", {
13 | enumerable: true,
14 | get: function get() {
15 | return _util["default"];
16 | }
17 | });
18 | Object.defineProperty(exports, "StorageService", {
19 | enumerable: true,
20 | get: function get() {
21 | return _storage["default"];
22 | }
23 | });
24 | Object.defineProperty(exports, "StoreService", {
25 | enumerable: true,
26 | get: function get() {
27 | return _store["default"];
28 | }
29 | });
30 |
31 | var _react = _interopRequireDefault(require("react"));
32 |
33 | var _reactRedux = require("react-redux");
34 |
35 | var _jservice = _interopRequireDefault(require("jservice"));
36 |
37 | var _collection = _interopRequireDefault(require("./collection"));
38 |
39 | var _provider = _interopRequireDefault(require("./provider"));
40 |
41 | var _util = _interopRequireDefault(require("./services/util"));
42 |
43 | var _storage = _interopRequireDefault(require("./services/storage"));
44 |
45 | var _store = _interopRequireDefault(require("./services/store"));
46 |
47 | function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
48 |
49 | function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { keys.push.apply(keys, Object.getOwnPropertySymbols(object)); } if (enumerableOnly) keys = keys.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); return keys; }
50 |
51 | function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(source, true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
52 |
53 | function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
54 |
55 | function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
56 |
57 | function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
58 |
59 | function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
60 |
61 | function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
62 |
63 | function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
64 |
65 | function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
66 |
67 | function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
68 |
69 | function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
70 |
71 | function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
72 |
73 | // DI container contexts
74 | var ContainerContext = _react["default"].createContext();
75 |
76 | var AsyncCountContext = _react["default"].createContext(0);
77 |
78 | var ReactServices =
79 | /*#__PURE__*/
80 | function (_BaseBuilder) {
81 | _inherits(ReactServices, _BaseBuilder);
82 |
83 | function ReactServices() {
84 | var _this;
85 |
86 | _classCallCheck(this, ReactServices);
87 |
88 | _this = _possibleConstructorReturn(this, _getPrototypeOf(ReactServices).call(this));
89 | _this.collection = new _collection["default"](_assertThisInitialized(_this));
90 | _this.provider = new _provider["default"](_this.collection);
91 | return _this;
92 | }
93 |
94 | _createClass(ReactServices, [{
95 | key: "createProvider",
96 | value: function createProvider() {
97 | throw new Error('Scoped providers are not supported yet');
98 | }
99 | }]);
100 |
101 | return ReactServices;
102 | }(_jservice["default"]);
103 |
104 | function createContainer() {
105 | return new ReactServices().build(function (services) {
106 | services.add(_util["default"]);
107 | services.add(_storage["default"]);
108 | services.add(_store["default"]);
109 | });
110 | }
111 |
112 | function mapStateToProps(serviceNames, state) {
113 | return serviceNames.reduce(function (result, name) {
114 | var val = state[name];
115 | if (val) result[name] = val;
116 | return result;
117 | }, {});
118 | }
119 |
120 | function withContainer(registry) {
121 | return function (ChildComponent) {
122 | return (
123 | /*#__PURE__*/
124 | function (_React$Component) {
125 | _inherits(_class, _React$Component);
126 |
127 | function _class(props) {
128 | var _this2;
129 |
130 | _classCallCheck(this, _class);
131 |
132 | _this2 = _possibleConstructorReturn(this, _getPrototypeOf(_class).call(this, props));
133 | _this2.state = {
134 | count: 0
135 | };
136 | _this2.container = createContainer().build(registry);
137 |
138 | _this2.container.start().then(function () {
139 | return _this2.forceUpdate();
140 | });
141 |
142 | _this2.contextValue = {
143 | container: _this2.container,
144 | asyncLoaded: function asyncLoaded() {
145 | _this2.setState({
146 | count: _this2.state.count + 1
147 | });
148 | }
149 | };
150 | return _this2;
151 | }
152 |
153 | _createClass(_class, [{
154 | key: "render",
155 | value: function render() {
156 | var store = this.container.provider.service('store').getStore();
157 |
158 | var childElement = _react["default"].createElement(ChildComponent, _objectSpread({
159 | container: this.container
160 | }, this.props));
161 |
162 | return _react["default"].createElement(ContainerContext.Provider, {
163 | value: this.contextValue
164 | }, _react["default"].createElement(AsyncCountContext.Provider, {
165 | value: this.state.count
166 | }, !store ? childElement : _react["default"].createElement(_reactRedux.Provider, {
167 | store: store
168 | }, childElement)));
169 | }
170 | }]);
171 |
172 | return _class;
173 | }(_react["default"].Component)
174 | );
175 | };
176 | }
177 |
178 | function withNewService(registry) {
179 | return function (ChildComponent) {
180 | return function (props) {
181 | return _react["default"].createElement(ContainerContext.Consumer, null, function (context) {
182 | context.container.build(registry);
183 | return _react["default"].createElement(ChildComponent, {
184 | container: context.container
185 | }, props.children);
186 | });
187 | };
188 | };
189 | }
190 |
191 | function withService() {
192 | for (var _len = arguments.length, serviceNames = new Array(_len), _key = 0; _key < _len; _key++) {
193 | serviceNames[_key] = arguments[_key];
194 | }
195 |
196 | return function (ChildComponent) {
197 | if (Array.isArray(serviceNames[serviceNames.length - 1])) {
198 | var states = serviceNames.pop();
199 | ChildComponent = withState.apply(null, states.length ? states : serviceNames)(ChildComponent);
200 | }
201 |
202 | return function (props) {
203 | return _react["default"].createElement(ContainerContext.Consumer, null, function (context) {
204 | return _react["default"].createElement(AsyncCountContext.Consumer, null, function () {
205 | return _react["default"].createElement(ChildComponent, _objectSpread({
206 | services: context.container.provider.createServices(serviceNames, context.asyncLoaded)
207 | }, props));
208 | });
209 | });
210 | };
211 | };
212 | }
213 |
214 | function withState() {
215 | for (var _len2 = arguments.length, serviceNames = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
216 | serviceNames[_key2] = arguments[_key2];
217 | }
218 |
219 | return function (ChildComponent) {
220 | if (Array.isArray(serviceNames[serviceNames.length - 1])) {
221 | var services = serviceNames.pop();
222 | ChildComponent = withService.apply(null, services.length ? services : serviceNames)(ChildComponent);
223 | }
224 |
225 | return (0, _reactRedux.connect)(function (state) {
226 | return {
227 | state: typeof serviceNames[0] === 'function' ? serviceNames[0](state) : mapStateToProps(serviceNames, state)
228 | };
229 | })(ChildComponent);
230 | };
231 | }
232 |
233 | function and() {
234 | for (var _len3 = arguments.length, serviceNames = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
235 | serviceNames[_key3] = arguments[_key3];
236 | }
237 |
238 | return Array.isArray(serviceNames[0]) ? serviceNames[0] : serviceNames;
239 | }
--------------------------------------------------------------------------------