@webqit/webflo 0.8.76 → 0.9.0

package/src/{runtime → runtime-pi}/client/Storage.js

@@ -6,30 +6,31 @@
 import { _isString, _isUndefined } from '@webqit/util/js/index.js';
 import { Observer } from './Runtime.js';
 
-export default function(persistent = false) {
+export default function(namespace = null, persistent = false) {
 
     const storeType = persistent ? 'localStorage' : 'sessionStorage';
     if (!window[storeType]) {
-        throw new Error(`The specified Web Storage API ${storeType} is invalid or not supported`)
+        throw new Error(`The specified Web Storage API ${storeType} is invalid or not supported`);
     }
 
     const _storage = {};
     Observer.intercept(_storage, (event, received, next) => {
-        if (event.type === 'get' && _isString(event.name)) {
-            const value = window[storeType].getItem(event.name);
+        const key = namespace ? `${namespace}.${event.name}` : event.name;
+        if (event.type === 'get' && _isString(key)) {
+            const value = window[storeType].getItem(key);
             return !_isUndefined(value) ? JSON.parse(value) : value;
         }
         if (event.type === 'set') {
-            window[storeType].setItem(event.name, !_isUndefined(event.value) ? JSON.stringify(event.value) : event.value);
+            window[storeType].setItem(key, !_isUndefined(event.value) ? JSON.stringify(event.value) : event.value);
             return true;
         }
         if (event.type === 'deleteProperty') {
-            window[storeType].removeItem(event.name);
+            window[storeType].removeItem(key);
             return true;
         }
         if (event.type === 'has') {
             for(var i = 0; i < window[storeType].length; i ++){
-                if (window[storeType].key(i) === event.name) {
+                if (window[storeType].key(i) === key) {
                     return true;
                 }
             };

package/src/{runtime → runtime-pi}/client/Url.js

@@ -2,12 +2,8 @@
 /**
  * @imports
  */
-import _isArray from '@webqit/util/js/isArray.js';
-import _isObject from '@webqit/util/js/isObject.js';
-import _isTypeObject from '@webqit/util/js/isTypeObject.js';
-import _isString from '@webqit/util/js/isString.js';
-import _isEmpty from '@webqit/util/js/isEmpty.js';
-import _with from '@webqit/util/obj/with.js';
+import { _with } from '@webqit/util/obj/index.js';
+import { _isArray, _isObject, _isTypeObject, _isString, _isEmpty } from '@webqit/util/js/index.js';
 import { wwwFormUnserialize, wwwFormSerialize } from '../util.js';
 import { Observer } from './Runtime.js';
 

package/src/{runtime/client/WorkerClient.js → runtime-pi/client/WorkerComm.js}

@@ -6,7 +6,7 @@
 import { _isFunction } from '@webqit/util/js/index.js';
 import { Observer } from './Runtime.js';
 
-export default class WorkerClient {
+export default class WorkerComm {
 
     constructor(file, params = {}) {
         this.ready = navigator.serviceWorker.ready;
@@ -73,7 +73,7 @@ export default class WorkerClient {
                 }
                 return this.post;
             },
-            receive: (callback, onAvailability = 1) => {
+            receive: callback => {
                 navigator.serviceWorker.addEventListener('message', callback);
                 return this.post;
             },

package/src/runtime-pi/client/generate.js

@@ -0,0 +1,242 @@
+
+/**
+ * imports
+ */
+import Fs from 'fs';
+import Url from 'url';
+import Path from 'path';
+import Webpack from 'webpack';
+import { _beforeLast } from '@webqit/util/str/index.js';
+import { _isObject, _isArray } from '@webqit/util/js/index.js';
+import * as DotJs from '@webqit/backpack/src/dotfiles/DotJs.js';
+
+/**
+ * @generate
+ */
+export async function generate() {
+    const cx = this || {};
+    // -----------
+    if (!cx.config.runtime?.Client) {
+        throw new Error(`The Client configurator "config.runtime.Client" is required in context.`);
+    }
+    const clientConfig = await (new cx.config.runtime.Client(cx)).read();
+    if (clientConfig.support_service_worker && !cx.config.runtime.client?.Worker) {
+        throw new Error(`The Service Worker configurator "config.runtime.client.Worker" is required in context.`);
+    }
+    const workerConfig = await (new cx.config.runtime.client.Worker(cx)).read();
+    // -----------
+    if (!cx.config.deployment?.Layout) {
+        throw new Error(`The Layout configurator "config.deployment.Layout" is required in context.`);
+    }
+    const layoutConfig = await (new cx.config.deployment.Layout(cx)).read();
+    const bundleOutput = { path: Path.resolve(cx.CWD || '', layoutConfig.PUBLIC_DIR), };
+    const dirSelf = Path.dirname(Url.fileURLToPath(import.meta.url)).replace(/\\/g, '/');
+    // -----------
+    // Generate client build
+    let genClient = getGen.call(cx, dirSelf, layoutConfig.CLIENT_DIR, clientConfig, `The Client Build.`);
+    if (clientConfig.support_oohtml) {
+        genClient.imports = { [`${dirSelf}/generate.oohtml.js`]: null, ...genClient.imports };
+    }
+    await bundle.call(cx, genClient, { ...bundleOutput, filename: 'bundle.js', }, true/* asModule */);
+    cx.logger && cx.logger.log('');
+    // -----------
+    // Generate worker build
+    if (clientConfig.support_service_worker) {
+        let genWorker = getGen.call(cx, `${dirSelf}/worker`, layoutConfig.WORKER_DIR, workerConfig, `The Worker Build.`);
+        await bundle.call(cx, genWorker, { ...bundleOutput, filename: 'worker.js', });
+        cx.logger && cx.logger.log('');
+    }
+}
+
+/**
+ * Compile routes.
+ * 
+ * @param string modulesDir
+ * @param string routesDir
+ * @param object paramsObj
+ * @param string desc
+ * 
+ * @return Object
+ */
+function getGen(modulesDir, routesDir, paramsObj, desc) {
+    const cx = this || {};
+    if (cx.logger) {
+        cx.logger.log(cx.logger.style.comment(`-----------------`));
+        cx.logger.log(desc);
+        cx.logger.log(cx.logger.style.comment(`-----------------`));
+        cx.logger.log('');
+    }
+    // ------------------
+    const gen = { imports: {}, code: [], };
+    // ------------------
+    // >> Modules import
+    gen.imports[`${modulesDir}/index.js`] = `{ start }`;
+    gen.code.push(``);
+    // ------------------
+    // >> Routes mapping
+    gen.code.push(`// >> Routes`);
+    declareRoutesObj.call(cx, gen, routesDir, 'layout', '');
+    gen.code.push(``);
+    // ------------------
+    // >> Params
+    gen.code.push(`// >> Params`);
+    declareParamsObj.call(cx, gen, paramsObj, 'params');
+    gen.code.push(``);
+    // ------------------
+    // >> Startup
+    gen.code.push(`// >> Startup`);
+    gen.code.push(`start.call({ layout, params })`);
+    return gen;
+}
+
+/**
+ * Compile routes.
+ * 
+ * @param object gen
+ * @param string routesDir
+ * @param string varName
+ * 
+ * @return void
+ */
+function declareRoutesObj(gen, routesDir, varName) {
+    const cx = this || {};
+    cx.logger && cx.logger.log(`> Declaring routes...`);
+    // ----------------
+    // Directory walker
+    const walk = (dir, callback) => {
+        Fs.readdirSync(dir).forEach(f => {
+            let resource = Path.join(dir, f);
+            if (Fs.statSync(resource).isDirectory()) {
+                walk(resource, callback);
+            } else {
+                let ext = Path.extname(resource) || '';
+                callback(resource, ext);
+            }
+        });
+    };
+    // ----------------
+    // >> Routes mapping
+    gen.code.push(`const ${varName} = {};`);
+    let indexCount = 0;
+    if (routesDir && Fs.existsSync(routesDir)) {
+        let clientDirname = routesDir.replace(/\\/g, '/').split('/').pop();
+        walk(routesDir, (file, ext) => {
+            //relativePath = relativePath.replace(/\\/g, '/');
+            if (file.replace(/\\/g, '/').endsWith('/index.js')) {
+                let relativePath = Path.relative(routesDir, file).replace(/\\/g, '/');
+                // Import code
+                let routeName = 'index' + (++ indexCount);
+                // IMPORTANT: we;re taking a step back here so that the parent-child relationship for 
+                // the directories be involved
+                gen.imports[`../${clientDirname}/${relativePath}`] = '* as ' + routeName;
+                // Definition code
+                let routePath = _beforeLast('/' + relativePath, '/index.js');
+                gen.code.push(`${varName}['${routePath || '/'}'] = ${routeName};`);
+                // Show
+                cx.logger && cx.logger.log(`> ./${relativePath}`);
+            }
+        });
+    }
+    if (!indexCount) {
+        cx.logger && cx.logger.log(`> (none)`);
+    }
+    cx.logger && cx.logger.log(``);
+}
+
+/**
+ * Compile params.
+ * 
+ * @param object    gen
+ * @param object    paramsObj
+ * @param string   varName
+ * 
+ * @return void
+ */
+function declareParamsObj(gen, paramsObj, varName = null, indentation = 0) {
+    const cx = this || {};
+    // ----------------
+    // Params compilation
+    if (varName) gen.code.push(`const ${varName} = {`);
+    _isArray(paramsObj)
+    Object.keys(paramsObj).forEach(name => {
+        let _name = `    ${'    '.repeat(indentation)}${(_isArray(paramsObj) ? '' : (name.includes(' ') ? `'${name}'` : name) + ': ')}`;
+        if ([ 'boolean', 'number' ].includes(typeof paramsObj[name])) {
+            gen.code.push(`${_name}${paramsObj[name]},`);
+        } else if (_isArray(paramsObj[name])) {
+            gen.code.push(`${_name}[`);
+            declareParamsObj.call(cx, gen, paramsObj[name], null, indentation + 1);
+            gen.code.push(`    ${'    '.repeat(indentation)}],`);
+        } else if (_isObject(paramsObj[name])) {
+            gen.code.push(`${_name}{`);
+            declareParamsObj.call(cx, gen, paramsObj[name], null, indentation + 1);
+            gen.code.push(`    ${'    '.repeat(indentation)}},`);
+        } else {
+            gen.code.push(`${_name}'${paramsObj[name]}',`);
+        }
+    });
+    if (varName) gen.code.push(`};`);
+}
+
+/**
+ * Bundle generated file
+ * 
+ * @param object    gen
+ * @param object    output
+ * @param boolean   asModule
+ * 
+ * @return Promise
+ */
+function bundle(gen, output, asModule = false) {
+    const cx = this || {};
+    const moduleFile = Path.join(output.path, `${_beforeLast(output.filename, '.')}.esm.js`);
+    // ------------------
+    // >> Show waiting...
+    if (cx.logger) {
+        let waiting = cx.logger.waiting(cx.logger.f`Writing the ES module file: ${moduleFile}`);
+        waiting.start();
+        DotJs.write(gen, moduleFile, 'ES Module file');
+        waiting.stop();
+        cx.logger.info(cx.logger.f`The module file: ${moduleFile}`);
+    } else {
+        DotJs.write(gen, moduleFile, 'ES Module file');
+    }
+    // ----------------
+    // >> Webpack config
+    const bundlingConfig = { entry: moduleFile, output };
+    if (asModule) {
+        bundlingConfig.experiments = { outputModule: true, };
+        bundlingConfig.output.environment = bundlingConfig.output.environment || {};
+        if (!('module' in bundlingConfig.output)) {
+            bundlingConfig.output.module = true;
+            bundlingConfig.output.environment.module = true;
+        }
+    }
+    // ----------------
+    // The bundling process
+    return new Promise(resolve => {
+        let waiting;
+        if (cx.logger) {
+            waiting = cx.logger.waiting(`Bundling...`);
+            cx.logger.log('');
+            cx.logger.log('> Bundling...');
+            cx.logger.info(cx.logger.f`FROM: ${bundlingConfig.entry}`);
+            cx.logger.info(cx.logger.f`TO: ${bundlingConfig.output.path + '/' + bundlingConfig.output.filename}`);
+            cx.logger.log('');
+            waiting.start();
+        }
+        // Run
+        let compiler = Webpack(bundlingConfig);
+        compiler.run((err, stats) => {
+            waiting.stop();
+            if (err) {
+                cx.logger.title(`Errors!`);
+                cx.logger.error(err);
+            }
+            let log = stats.toString({ colors: true, });
+            cx.logger && cx.logger.log(log);
+            // Remove moduleFile build
+            //Fs.unlinkSync(bundlingConfig.entry);
+            resolve(log);
+        });
+    });
+}

package/src/runtime-pi/client/generate.oohtml.js

@@ -0,0 +1,7 @@
+
+/**
+ * @imports
+ */
+import { OOHTML } from '@webqit/oohtml-ssr/apis.js';
+
+OOHTML.call( window );

package/src/runtime-pi/client/index.js

@@ -0,0 +1,18 @@
+
+/**
+ * @imports
+ */
+import Context from './Context.js';
+import RuntimeClient from './RuntimeClient.js';
+import Runtime from './Runtime.js';
+
+/**
+ * @start
+ */
+export async function start(clientCallback = null) {
+    const cx = this || {};
+    const defaultClientCallback = _cx => new RuntimeClient(_cx);
+    return new Runtime(Context.create(cx), ( ...args ) => {
+        return clientCallback ? clientCallback( ...args.concat( defaultClientCallback ) ) : defaultClientCallback( ...args );
+    });
+}

package/src/runtime-pi/client/whatwag.js

@@ -0,0 +1,27 @@
+
+const {
+    URL,
+    fetch,
+    Headers,
+    Request,
+    Response,
+    FormData,
+    ReadableStream,
+    File,
+    Blob
+} = globalThis;
+
+/**
+ * @exports
+ */
+export {
+    URL,
+    fetch,
+    Headers,
+    Request,
+    Response,
+    FormData,
+    ReadableStream,
+    File,
+    Blob,
+}

package/src/runtime-pi/client/worker/Context.js

@@ -0,0 +1,7 @@
+
+/**
+ * @imports
+ */
+import _Contex from '../Context.js';
+
+export default class Context extends _Contex {}

package/src/runtime-pi/client/worker/Worker.js

@@ -0,0 +1,243 @@
+
+/**
+ * @imports
+ */
+import _isGlobe from 'is-glob';
+import Minimatch from 'minimatch';
+import { _any } from '@webqit/util/arr/index.js';
+import { _after, _afterLast } from '@webqit/util/str/index.js';
+import { HttpEvent, Request, Response } from '../Runtime.js';
+import { Observer } from '../Runtime.js';
+
+/**
+ * ---------------------------
+ * The Worker Initializer
+ * ---------------------------
+ */
+
+export default class Worker {
+
+	/**
+     * Runtime
+     * 
+     * @param Object        cx
+     * @param Function      clientCallback
+     * 
+     * @return void
+     */
+	constructor(cx, clientCallback) {
+
+        // ---------------
+		this.cx = cx;
+        this.clients = new Map;
+        this.mockSessionStore = {};
+        // ---------------
+		this.cx.runtime = this;
+		let client = clientCallback(this.cx, '*');
+        if (!client || !client.handle) throw new Error(`Application instance must define a ".handle()" method.`);
+		this.clients.set('*', client);
+		
+		// -------------
+		// ONINSTALL
+		self.addEventListener('install', evt => {
+			if (this.cx.params.skip_waiting) { self.skipWaiting(); }
+			// Manage CACHE
+			if (this.cx.params.cache_name && (this.cx.params.cache_only_urls || []).length) {
+				// Add files to cache
+				evt.waitUntil( self.caches.open(this.cx.params.cache_name).then(cache => {
+					if (this.cx.logger) { this.cx.logger.log('[ServiceWorker] Pre-caching resources.'); }
+					const cache_only_urls = (this.cx.params.cache_only_urls || []).map(c => c.trim()).filter(c => c);
+					return cache.addAll(cache_only_urls.filter(url => !_isGlobe(url) && !_afterLast(url, '.').includes('/')));
+				}) );
+			}
+		});
+
+		// -------------
+		// ONACTIVATE
+		self.addEventListener('activate', evt => {
+			evt.waitUntil( new Promise(async resolve => {
+				if (this.cx.params.skip_waiting) { await self.clients.claim(); }
+				// Manage CACHE
+				if (this.cx.params.cache_name) {
+					// Clear outdated CACHES
+					await self.caches.keys().then(keyList => {
+						return Promise.all(keyList.map(key => {
+							if (key !== this.cx.params.cache_name && key !== this.cx.params.cache_name + '_json') {
+								if (this.cx.logger) { this.cx.logger.log('[ServiceWorker] Removing old cache:', key); }
+								return self.caches.delete(key);
+							}
+						}));
+					}) 
+				}
+				resolve();
+			}) );
+		});
+
+		// -------------
+		// ONFETCH		
+		self.addEventListener('fetch', async evt => {
+			// URL schemes that might arrive here but not supported; e.g.: chrome-extension://
+			if (!evt.request.url.startsWith('http')) return;
+			const requestInit = [
+				'method', 'headers', 'body', 'mode', 'credentials', 'cache', 'redirect', 'referrer', 'integrity',
+			].reduce((init, prop) => ({ [prop]: evt.request[prop], ...init }), {});
+			evt.respondWith(this.go(evt.request.url, requestInit, { event: evt }));
+		});
+
+		// ---------------
+        Observer.set(this, 'location', {});
+        Observer.set(this, 'network', {});
+        // ---------------
+	}
+
+	/**
+     * Performs a request.
+     *
+     * @param object|string 	url
+     * @param object 			init
+     * @param object 			detail
+     *
+     * @return Response
+     */
+	async go(url, init = {}, detail = {}) {
+		// ------------
+        url = typeof url === 'string' ? new URL(url) : url;
+		init = { referrer: this.location.href, ...init };
+        // ------------
+		// The request object
+		let request = this.generateRequest(url.href, init);
+		// The navigation event
+		let httpEvent = new HttpEvent(request, detail, (id = null, persistent = false) => this.getSession(httpEvent, id, persistent));
+		httpEvent.port.listen(message => {
+			if (message.$type === 'handler:hints' && message.session) {
+				// TODO: Sync sesseion data from client
+				return Promise.resolve();
+			}
+		});
+		// Response
+		let response;
+		if (httpEvent.request.url.startsWith(self.origin)/* && httpEvent.request.mode === 'navigate'*/) {
+			response = await this.clients.get('*').handle(httpEvent, (...args) => this.remoteFetch(...args));
+		} else {
+			response = await this.remoteFetch(httpEvent.request);
+		}
+		let finalResponse = this.handleResponse(httpEvent, response);
+        // Return value
+        return finalResponse;
+	}
+
+    // Generates request object
+    generateRequest(href, init) {
+		// Now, the following is key:
+		// The browser likes to use "force-cache" for "navigate" requests
+		// when, for example, the back button was used.
+		// Thus the origin server would still not be contacted by the self.fetch() below, leading to inconsistencies in responses.
+		// So, we detect this scenerio and avoid it.
+		if (init.mode === 'navigate' && init.cache === 'force-cache') {
+			init = { ...init, cache: 'default' };
+		}
+        let request = new Request(href, init);
+		return request;
+    }
+
+    // Generates session object
+    getSession(e, id = null, persistent = false) {
+		return {
+			get: () => this.mockSessionStore,
+			set: value => { this.mockSessionStore = value },
+		};
+	}
+
+	// Initiates remote fetch and sets the status
+	remoteFetch(request) {
+		const execFetch = () => {
+			if (_any((this.cx.params.cache_only_urls || []).map(c => c.trim()).filter(c => c), pattern => Minimatch.Minimatch(request.url, pattern))) {
+				Observer.set(this.network, 'strategy', 'cache-only');
+				return this.cacheFetch(request, { networkFallback: false, cacheRefresh: false });
+			}
+			// network_only_urls
+			if (_any((this.cx.params.network_only_urls || []).map(c => c.trim()).filter(c => c), pattern => Minimatch.Minimatch(request.url, pattern))) {
+				Observer.set(this.network, 'strategy', 'network-only');
+				return this.networkFetch(request, { cacheFallback: false, cacheRefresh: false });
+			}
+			// cache_first_urls
+			if (_any((this.cx.params.cache_first_urls || []).map(c => c.trim()).filter(c => c), pattern => Minimatch.Minimatch(request.url, pattern))) {
+				Observer.set(this.network, 'strategy', 'cache-first');
+				return this.cacheFetch(request, { networkFallback: true, cacheRefresh: true });
+			}
+			Observer.set(this.network, 'strategy', 'network-first');
+			return this.networkFetch(request, { cacheFallback: true, cacheRefresh: true });
+		};
+		let response = execFetch(request);
+		// This catch() is NOT intended to handle failure of the fetch
+		response.catch(e => Observer.set(this.network, 'error', e.message));
+		// Return xResponse
+		return response.then(_response => new Response(_response));
+	}
+
+	// Caching strategy: cache_first
+	cacheFetch(request, params = {}) {
+		return this.getRequestCache(request).then(cache => cache.match(request).then(response => {
+			// Nothing cache, use network
+			if (!response && params.networkFallback) return this.networkFetch(request, { ...params, cacheFallback: false });
+			// Note: fetch, but for refreshing purposes only... not the returned response
+			if (response && params.cacheRefresh) this.networkFetch(request, { ...params, justRefreshing: true });
+			Observer.set(this.network, 'cache', true);
+			return response;
+		}));
+	}
+
+	// Caching strategy: network_first
+	networkFetch(request, params = {}) {
+		if (params.forceNetwork) {
+			let url = new URL(request.url);
+			url.searchParams.set('$force-cache', '1');
+			request.attr.url = url.toString();
+		}
+		if (!params.cacheFallback) {
+			Observer.set(this.network, 'remote', true);
+			return self.fetch(request);
+		}
+		return self.fetch(request).then(response => {
+			if (params.cacheRefresh) this.refreshCache(request, response);
+			Observer.set(this.network, 'remote', true);
+			return response;
+		}).catch(() => this.getRequestCache(request).then(cache => {
+			Observer.set(this.network, 'cache', true);
+			return cache.match(request);
+		}));
+	}
+
+	// Caches response 
+	refreshCache(request, response) {
+		// Check if we received a valid response
+		if (request.method !== 'GET' || !response || response.status !== 200 || (response.type !== 'basic' && response.type !== 'cors')) {
+			return response;
+		}
+		// IMPORTANT: Clone the response. A response is a stream
+		// and because we want the browser to consume the response
+		// as well as the cache consuming the response, we need
+		// to clone it so we have two streams.
+		var responseToCache = response.clone();
+		this.getRequestCache(request).then(cache => {
+			Observer.set(this.network, 'cacheRefresh', true);
+			cache.put(request, responseToCache);
+		});
+		return response;
+	}
+
+	// Returns either the regular cache or a json-specific cache
+	getRequestCache(request) {
+		let cacheName = request.headers.get('Accept') === 'application/json'
+			? this.cx.params.cache_name + '_json' 
+			: this.cx.params.cache_name;
+		return self.caches.open(cacheName);
+	}
+
+	// Handles response object
+	handleResponse(e, response) {
+		if (!(response instanceof Response)) { response = new Response(response); }
+		return response;
+	}
+
+}

package/src/runtime-pi/client/worker/WorkerClient.js

@@ -0,0 +1,46 @@
+
+/**
+ * @imports
+ */
+import Router from '../Router.js';
+
+export default class WorkerClient {
+
+	/**
+     * WorkerClient
+     * 
+     * @param Context cx
+     */
+	constructor(cx) {
+		this.cx = cx;
+	}
+
+	 /**
+     * Handles HTTP events.
+     * 
+     * @param HttpEvent       httpEvent
+     * @param Function        remoteFetch
+     * 
+     * @return Response
+     */
+	async handle(httpEvent, remoteFetch) {
+		// The app router
+        const router = new Router(this.cx, httpEvent.url.pathname);
+        const handle = async () => {
+			// --------
+			// ROUTE FOR DATA
+			// --------
+			let httpMethodName = httpEvent.request.method.toLowerCase();
+			let response = await router.route([httpMethodName === 'delete' ? 'del' : httpMethodName, 'default'], httpEvent, {}, async event => {
+				return remoteFetch(event.request);
+			}, remoteFetch);
+			if (!(response instanceof httpEvent.Response)) {
+                response = new httpEvent.Response(response);
+            }
+            return response;
+		};
+        return handle();
+	}
+
+}
+

package/src/runtime-pi/client/worker/index.js

@@ -0,0 +1,18 @@
+
+/**
+ * @imports
+ */
+import Context from './Context.js';
+import WorkerClient from './WorkerClient.js';
+import Worker from './Worker.js';
+
+/**
+ * @start
+ */
+export async function start(clientCallback = null) {
+    const cx = this || {};
+    const defaultClientCallback = _cx => new WorkerClient(_cx);
+    return new Worker(Context.create(cx), ( ...args ) => {
+        return clientCallback ? clientCallback( ...args.concat( defaultClientCallback ) ) : defaultClientCallback( ...args );
+    });
+}