bigpipe-util 0.1.1

package/.editorconfig

@@ -0,0 +1,9 @@
+root = true
+
+[*]
+charset = utf-8
+end_of_line = lf
+indent_size = 2
+indent_style = space
+insert_final_newline = true
+trim_trailing_whitespace = true

package/CHANGELOG.md

@@ -0,0 +1,10 @@
+# Changelog
+
+All notable changes to `bigpipe-util` will be documented in this file.
+
+Updates should follow the [Keep a CHANGELOG](http://keepachangelog.com/) principles.
+
+## v0.1.1 - 2022-03-27
+
+### Added
+- Part of BigPipe implementation for Webpack.

package/LICENSE

@@ -0,0 +1,19 @@
+Copyright (C) 2017 Richard Dobroň
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/README.md

@@ -0,0 +1,133 @@
+<img src="bigpipe.svg">
+
+This library currently implements small part of [Facebook BigPipe][blog] so far, but the advantage is to efficiently insert/replace content and work with the DOM. It is also possible to easily call JavaScript modules from PHP.
+
+
+## Demo App
+Try the app with [live demo](http://bigpipe.xf.cz).
+
+## Requirements
+* PHP 7.1 or higher
+* Node 8, 10+.
+* Webpack
+
+## Installation
+
+These steps are required:
+1. Install composer package:
+```shell
+$ composer require richarddobron/bigpipe
+```
+
+2. Install npm package:
+```shell
+$ npm install bigpipe-util
+```
+
+3. Add this lines to /path/to/resources/js/app.js:
+```javascript
+import Primer from 'bigpipe-util/src/Primer';
+
+Primer();
+
+window.require = (modulePath) => {
+  return modulePath.startsWith('bigpipe-util/')
+    ? require('bigpipe-util/' + modulePath.substring(13) + '.js').default
+    : require('./' + modulePath).default;
+};
+```
+
+4. Create file /path/to/resources/js/ServerJS.js
+   - this step is optional, but if you skip it, use this in next step:
+   ```require("bigpipe-util/ServerJS")```
+```javascript
+import ServerJSImpl from 'bigpipe-util/src/ServerJS';
+export default class ServerJS extends ServerJSImpl {
+}
+```
+
+5. Add this lines to page footer:
+```html
+<script>
+    (new (require("ServerJS"))).handle(<?=json_encode(\dobron\BigPipe\BigPipe::jsmods())?>);
+</script>
+```
+
+## Request API
+
+```javascript
+import AsyncRequest from 'bigpipe-util/src/AsyncRequest';
+
+const request = AsyncRequest('/ajax/remove.php')
+  // or .setURI('/ajax/remove.php')
+  .setMethod('POST')
+  .setData({
+    param: 'value',
+  })
+  .setInitialHandler(() => {
+      // pre-request callback function
+  })
+  .setHandler((jsonResponse) => {
+      // A function to be called if the request succeeds
+  })
+  .setErrorHandler((xhr) => {
+      // A function to be called if the request fails
+  })
+  .send();
+
+if (OH_NOES_WE_NEED_TO_CANCEL_RIGHT_NOW_OR_ELSE) {
+  request.abort();
+}
+```
+
+# What all can be Ajaxifed?
+
+## Links
+```html
+<a href="#"
+   ajaxify="/ajax/remove.php"
+   rel="async">Remove Item</a>
+```
+
+## Forms
+```html
+<form action="/submit.php"
+      method="POST"
+      rel="async">
+    <input name="user">
+    <input type="submit" name="Done">
+</form>
+```
+
+## Dialogs
+```html
+<a href="#"
+   ajaxify="/ajax/modal.php"
+   rel="dialog">Open Modal</a>
+```
+
+## Credits
+
+- [Richard Dobroň][link-author]
+
+## Inspiration
+
+BigPipe is inspired by the concept behind Facebook's BigPipe. For more details
+read their blog post: [Pipelining web pages for high performance][blog].
+
+## Motivation
+
+There is a large number of PHP projects for which moving to modern frameworks like Laravel Livewire, React, Vue.js (and many more!) could be very challenging.
+
+The purpose of this library is to rapidly reduce the continuously repetitive code to work with the DOM and improve the communication barrier between PHP and JavaScript.
+
+## Credits
+
+- [Richard Dobroň][link-author]
+
+## License
+
+The MIT License (MIT). Please see [License File](LICENSE.md) for more information.
+
+[link-author]: https://github.com/richardDobron
+[blog]: https://www.facebook.com/notes/facebook-engineering/bigpipe-pipelining-web-pages-for-high-performance/389414033919

package/bigpipe.svg

@@ -0,0 +1,13 @@
+<svg width="254.23999568394254" height="64.8" viewBox="0 0 254.23999568394254 64.8" xmlns="http://www.w3.org/2000/svg">
+    <g transform="matrix(3.0856473041983374,0,0,3.0856473041983374,-6.171373325690784,-6.1698442238608315)" fill="#0C056D">
+        <g xmlns="http://www.w3.org/2000/svg">
+            <path d="M2.2427,8.9287a.5.5,0,0,1,0-.8574l10-6a.4971.4971,0,0,1,.5146,0l10,6a.5.5,0,0,1,0,.8574l-10,6a.5.5,0,0,1-.5146,0Zm20,3.1426L12.5,17.917,2.7573,12.0713a.5.5,0,0,0-.5146.8574l10,6a.5.5,0,0,0,.5146,0l10-6a.5.5,0,0,0-.5146-.8574Zm0,4L12.5,21.917,2.7573,16.0713a.5.5,0,0,0-.5146.8574l10,6a.5.5,0,0,0,.5146,0l10-6a.5.5,0,0,0-.5146-.8574Z"></path>
+        </g>
+    </g>
+    <g transform="matrix(2.500000066227385,0,0,2.500000066227385,81.99999920527138,0.49999675485814166)" fill="#0C056D">
+        <path d="M8.92 12.24 c1.48 0.4 2.88 1.72 2.88 3.66 c0 2.54 -1.6 4.1 -5.08 4.1 l-5.52 0 l0 -14 l5.22 0 c2.9 0 4.36 1.64 4.36 3.52 c0 1.48 -0.96 2.32 -1.86 2.72 z M6.14 8.56 l-2.02 0 l0 2.82 l2.02 0 c1.24 0 1.74 -0.58 1.74 -1.42 c0 -0.9 -0.58 -1.4 -1.74 -1.4 z M6.56 17.44 c1.6 0 2.32 -0.66 2.32 -1.9 c0 -1.06 -0.72 -1.8 -2.44 -1.8 l-2.32 0 l0 3.7 l2.44 0 z M16.62 6 l0 14 l-2.92 0 l0 -14 l2.92 0 z M32.2 12.559999999999999 c0.62 4.7 -2.44 7.64 -6.22 7.64 c-3.98 0 -7.26 -2.94 -7.26 -7.2 s3.36 -7.2 7.26 -7.2 c1.86 0 3.5 0.6 4.7 1.66 l-1.76 1.98 c-0.74 -0.52 -1.74 -0.9 -2.76 -0.9 c-2.54 0 -4.4 1.86 -4.4 4.46 s1.8 4.46 4.22 4.46 c1.84 0 3.12 -0.66 3.52 -2.42 l-3.3 0 l0 -2.48 l6 0 z"></path>
+    </g>
+    <g transform="matrix(2.5714285714285716,0,0,2.5714285714285716,166.91428559167045,-0.4285714285714306)" fill="#0C056D">
+        <path d="M5.46 6 c3.14 0 4.8 1.94 4.8 4.3 c0 2.42 -1.66 4.34 -4.8 4.34 l-3.68 0 l0 5.36 l-0.58 0 l0 -14 l4.26 0 z M5.54 14.04 c2.52 0 4.14 -1.46 4.14 -3.74 c0 -2.32 -1.62 -3.72 -4.14 -3.72 l-3.76 0 l0 7.46 l3.76 0 z M12.74 6 l0 14 l-0.58 0 l0 -14 l0.58 0 z M19.400000000000002 6 c3.14 0 4.8 1.94 4.8 4.3 c0 2.42 -1.66 4.34 -4.8 4.34 l-3.68 0 l0 5.36 l-0.58 0 l0 -14 l4.26 0 z M19.48 14.04 c2.52 0 4.14 -1.46 4.14 -3.74 c0 -2.32 -1.62 -3.72 -4.14 -3.72 l-3.76 0 l0 7.46 l3.76 0 z M26.680000000000003 19.42 l7.28 0 l0 0.58 l-7.68 0 l-0.18 0 l0 -14 l0.58 0 l7.1 0 l0 0.58 l-7.1 0 l0 6.1 l5.66 0 l0 0.58 l-5.66 0 l0 6.16 z"></path>
+    </g>
+</svg>

package/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "bigpipe-util",
+  "description": "This library currently implements small part of Facebook BigPipe so far, but the advantage is to efficiently insert/replace content and work with the DOM. It is also possible to easily call JavaScript modules from PHP.",
+  "version": "0.1.1",
+  "keywords": [
+    "bigpipe",
+    "xhr",
+    "html",
+    "dom",
+    "async",
+    "javascript"
+  ],
+  "homepage": "https://github.com/richardDobron/bigpipe-util",
+  "author": "Richard Dobroň",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/richardDobron/bigpipe-util.git"
+  },
+  "bugs:": "https://github.com/richardDobron/bigpipe-util/issues",
+  "license": "MIT",
+  "dependencies": {
+    "fbjs": "^3.0.4"
+  }
+}

package/src/Primer.js

@@ -0,0 +1,103 @@
+import AsyncRequest from "./async/AsyncRequest";
+import {byTag} from "./core/Parent";
+
+export default function Primer() {
+  const rootElement = document.documentElement;
+
+  const RELATIONSHIP_REGEX = /async(?:-post)?/;
+
+  rootElement.onclick = function (event) {
+    event = event || window.event;
+    const elementOnClicked = event.target || event.srcElement;
+
+    const linkNodeOnClicked = byTag(elementOnClicked, "A");
+
+    if (!linkNodeOnClicked) {
+      return;
+    }
+
+    let relationship = linkNodeOnClicked.rel && linkNodeOnClicked.rel.match(RELATIONSHIP_REGEX);
+    relationship = relationship && relationship[0];
+
+    switch (relationship) {
+      case "async":
+      case "async-post":
+        event.preventDefault();
+
+        (new AsyncRequest(linkNodeOnClicked.getAttribute("ajaxify")))
+          .setRelative(linkNodeOnClicked)
+          .setMethod(relationship === "async-post" ? "POST" : "GET")
+          .send();
+        break;
+    }
+  };
+
+  rootElement.onsubmit = function (event) {
+    event = event || window.event;
+    const eventTarget = event.target || event.srcElement;
+
+    if (eventTarget &&
+      eventTarget.nodeName === "FORM" &&
+      eventTarget.getAttribute("rel") === "async") {
+      event.preventDefault();
+
+      const submitter = event.submitter || eventTarget.querySelector("button[type='submit']"),
+        activeControls = eventTarget.querySelectorAll("input:not([readonly]),select:not([readonly]),textarea:not([readonly])");
+
+      (new AsyncRequest(eventTarget.getAttribute("ajaxify") || eventTarget.getAttribute("action")))
+        .setMethod(eventTarget.method || "POST")
+        .setRelative(eventTarget)
+        .setData(new FormData(eventTarget))
+        .setInitialHandler(function () {
+          if (!eventTarget.classList.contains("disable-prevent-form")) {
+            activeControls.forEach(function (control) {
+              control.setAttribute("readonly", "readonly");
+            });
+
+            if (submitter) {
+              submitter.disabled = true;
+            }
+          }
+
+          if (eventTarget) {
+            const loader = eventTarget.querySelector(".form-loader");
+
+            if (loader) {
+              loader.classList.add("loading");
+            }
+          }
+        })
+        .setHandler(function (response) {
+          activeControls.forEach(function (control) {
+            control.removeAttribute("readonly");
+          });
+
+          if (submitter) {
+            submitter.disabled = false;
+          }
+
+          if (eventTarget) {
+            const loader = eventTarget.querySelector(".small-loader");
+
+            if (loader) {
+              loader.classList.remove("loading");
+            }
+          }
+        })
+        .setErrorHandler(function () {
+          activeControls.forEach(function (control) {
+            control.removeAttribute("readonly");
+          });
+
+          if (eventTarget) {
+            const loader = eventTarget.querySelector(".small-loader");
+
+            if (loader) {
+              loader.classList.remove("loading");
+            }
+          }
+        })
+        .send();
+    }
+  };
+}

package/src/ServerJS.js

@@ -0,0 +1,41 @@
+import replaceTransportMarkers from "./core/replaceTransportMarkers";
+
+function handler(dependencies, guard, context) {
+  return dependencies.map(function (args) {
+    guard.apply(context, args);
+  });
+}
+
+export default class ServerJS {
+  constructor() {
+    this._relativeTo = document.body;
+  }
+
+  handle(jsMods) {
+    handler(jsMods.require || [], this._handleRequire, this);
+  }
+
+  _handleRequire(modulePath, method, marker) {
+    if (method && typeof method === 'string') {
+      if (marker) {
+        replaceTransportMarkers(this._relativeTo, marker);
+      }
+
+      const context = new (window.require(modulePath));
+
+      if (!context[method]) {
+        throw new TypeError(`Module ${modulePath} has no method "${method}"`);
+      }
+
+      context[method].apply(context, marker || []);
+    } else {
+      marker = method;
+
+      if (marker) {
+        replaceTransportMarkers(this._relativeTo, marker);
+      }
+
+      new (window.require(modulePath))(...(marker || []));
+    }
+  }
+}

package/src/async/AsyncDOM.js

@@ -0,0 +1,51 @@
+import DOM from "../core/DOM";
+
+export default class AsyncDOM {
+  invoke(domOps, element) {
+    for (let i = 0; i < domOps.length; ++i) {
+      let domOp = domOps[i],
+        type = domOp[0],
+        selector = domOp[1],
+        enableTarget = domOp[2],
+        content = domOp[3];
+
+      let node = enableTarget && element || null;
+
+      if (selector) {
+        node = (node || document.documentElement).querySelector(selector);
+      }
+
+      switch (type) {
+        case "eval":
+          (new Function(content)).apply(node);
+          break;
+        case "hide":
+          node.style.display = "none";
+          break;
+        case "show":
+          node.style.display = "";
+          break;
+        case "setContent":
+          DOM.setContent(node, content.__html);
+          break;
+        case "appendContent":
+          DOM.appendContent(node, content.__html);
+          break;
+        case "prependContent":
+          DOM.prependContent(node, content.__html);
+          break;
+        case "insertAfter":
+          DOM.insertAfter(node, content.__html);
+          break;
+        case "insertBefore":
+          DOM.insertBefore(node, content.__html);
+          break;
+        case "remove":
+          DOM.remove(node);
+          break;
+        case "replace":
+          DOM.replace(node, content.__html);
+      }
+    }
+  }
+};

package/src/async/AsyncRequest.js

@@ -0,0 +1,171 @@
+import emptyFunction from "fbjs/lib/emptyFunction";
+import AsyncResponse from "./AsyncResponse";
+
+function serialize(obj, prefix) {
+  const str = [];
+  for(const p in obj) {
+    if (obj.hasOwnProperty(p)) {
+      const k = prefix ? prefix + "[" + p + "]" : p, v = obj[p];
+      str.push(typeof v == "object" ?
+        serialize(v, k) :
+        encodeURIComponent(k) + "=" + encodeURIComponent(v));
+    }
+  }
+  return str.join("&");
+}
+
+function validateResponseHandler(handler) {
+  const valid = !handler || typeof handler === "function";
+
+  if (!valid) {
+    console.error("AsyncRequest response handlers must be functions. Pass a function, or use bind() to build one.");
+  }
+
+  return valid;
+}
+
+export default function AsyncRequest(uri) {
+  this.method = "POST";
+  this.uri = "";
+  this.relative = null;
+  this.data = {};
+  this.headers = {};
+  this.initialHandler = emptyFunction;
+  this.handler = null;
+  this.errorHandler = emptyFunction;
+
+  if (uri !== undefined) {
+    this.setURI(uri);
+  }
+}
+
+AsyncRequest.prototype.setMethod = function (method) {
+  this.method = method.toString().toUpperCase();
+  return this;
+};
+
+AsyncRequest.prototype.getMethod = function () {
+  return this.method;
+};
+
+AsyncRequest.prototype.setRelative = function (relative) {
+  this.relative = relative;
+  return this;
+};
+
+AsyncRequest.prototype.getRelative = function () {
+  return this.relative;
+};
+
+AsyncRequest.prototype.setData = function (obj) {
+  this.data = obj;
+  return this;
+};
+
+AsyncRequest.prototype.getData = function () {
+  return this.data;
+};
+
+AsyncRequest.prototype.setRequestHeader = function (name, value) {
+  this.headers[name] = value;
+  return this;
+};
+
+AsyncRequest.prototype.setURI = function (uri) {
+  this.uri = uri;
+
+  return this;
+};
+AsyncRequest.prototype.getURI = function () {
+  return this.uri;
+};
+
+AsyncRequest.prototype.setInitialHandler = function (fn) {
+  this.initialHandler = fn;
+  return this;
+};
+
+AsyncRequest.prototype.getInitialHandler = function () {
+  return this.initialHandler || emptyFunction;
+};
+
+AsyncRequest.prototype.setHandler = function (fn) {
+  if (validateResponseHandler(fn)) {
+    this.handler = fn;
+  }
+  return this;
+};
+
+AsyncRequest.prototype.getHandler = function () {
+  return this.handler || emptyFunction;
+};
+
+AsyncRequest.prototype.setErrorHandler = function (fn) {
+  if (validateResponseHandler(fn)) {
+    this.errorHandler = fn;
+  }
+  return this;
+};
+
+AsyncRequest.prototype.getErrorHandler = function () {
+  return this.errorHandler || emptyFunction;
+};
+
+AsyncRequest.prototype.abort = function () {
+  const transport = this.transport;
+
+  if (transport) {
+    transport.abort();
+  }
+};
+
+AsyncRequest.prototype.send = function () {
+  const {uri, method} = this;
+  let { data } = this;
+
+  const handler = this.getHandler();
+  const errorHandler = this.getErrorHandler();
+  const initialHandler = this.getInitialHandler();
+
+  initialHandler();
+
+  const request = new XMLHttpRequest();
+  const self = this;
+
+  request.open(method, uri, true);
+
+  request.onload = function () {
+    if (this.status >= 200 && this.status < 400) {
+      let response;
+      try {
+        response = eval("(" + this.responseText + ")");
+      } catch (e) {
+        throw new Error("Failed to handle response: " + e.message + "\n" + this.responseText);
+      }
+
+      (new AsyncResponse).handle(response, self.relative);
+
+      handler(response);
+    } else {
+      errorHandler(this);
+    }
+  };
+
+  request.setRequestHeader("X-Requested-With", "XMLHttpRequest");
+  if (!(this.data instanceof FormData)) {
+    data = serialize(data);
+
+    if (method === "POST") {
+      request.setRequestHeader("Content-Type", "application/x-www-form-urlencoded");
+    }
+  }
+
+  Object.keys(this.headers).forEach((name) => {
+    request.setRequestHeader(name, this.headers[name]);
+  });
+
+  request.onerror = errorHandler;
+  request.send(data);
+
+  return request;
+};

package/src/async/AsyncResponse.js

@@ -0,0 +1,21 @@
+import AsyncDOM from "./AsyncDOM";
+import ServerJS from "../ServerJS";
+
+const _AsyncDOM = new AsyncDOM;
+const _ServerJS = new ServerJS;
+
+export default class AsyncResponse {
+  handle(response, element) {
+    const {domops, jsmods} = response;
+
+    if (typeof response === 'object') {
+      if (domops) {
+        _AsyncDOM.invoke(domops, element);
+      }
+
+      if (jsmods) {
+        _ServerJS.handle(jsmods);
+      }
+    }
+  }
+};

package/src/core/$.js

@@ -0,0 +1,3 @@
+export default function (elementId) {
+  return document.getElementById(elementId);
+}

package/src/core/DOM.js

@@ -0,0 +1,41 @@
+function removeNode(node) {
+  if (node.parentNode) {
+    node.parentNode.removeChild(node);
+  }
+}
+
+export default {
+  prependContent(node, content) {
+    node.insertAdjacentHTML("afterbegin", content);
+  },
+
+  insertAfter(node, content) {
+    node.insertAdjacentHTML("afterend", content);
+  },
+
+  insertBefore(node, content) {
+    node.insertAdjacentHTML("beforebegin", content);
+  },
+
+  setContent(node, content) {
+    node.innerHTML = content;
+  },
+
+  appendContent(node, content) {
+    node.insertAdjacentHTML("beforeend", content);
+  },
+
+  replace(node, content) {
+    node.outerHTML = content;
+  },
+
+  remove(node) {
+    removeNode(node);
+  },
+
+  empty(node) {
+    while (node.firstChild) {
+      removeNode(node.firstChild);
+    }
+  }
+}

package/src/core/Parent.js

@@ -0,0 +1,9 @@
+export function byTag(node, tagName) {
+  tagName = tagName.toUpperCase();
+
+  while (node && node.nodeName !== tagName) {
+    node = node.parentNode;
+  }
+
+  return node;
+}

package/src/core/ReloadPage.js

@@ -0,0 +1,9 @@
+export default class ReloadPage {
+  now() {
+    window.location.reload();
+  }
+
+  delay(delay) {
+    setTimeout(this.now.bind(this), delay);
+  }
+}

package/src/core/ServerRedirect.js

@@ -0,0 +1,7 @@
+export default class ServerRedirect {
+  redirectPageTo(url, delay = 0) {
+    setTimeout(function () {
+      window.location = url;
+    }, delay);
+  }
+}

package/src/core/copyProperties.js

@@ -0,0 +1,46 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ *
+ * @providesModule copyProperties
+ */
+'use strict';
+
+/**
+ * Copy properties from one or more objects (up to 5) into the first object.
+ * This is a shallow copy. It mutates the first object and also returns it.
+ *
+ * NOTE: `arguments` has a very significant performance penalty, which is why
+ * we don't support unlimited arguments.
+ */
+export default function copyProperties(obj, a, b, c, d, e, f) {
+  obj = obj || {};
+
+  if (__DEV__) {
+    if (f) {
+      throw new Error('Too many arguments passed to copyProperties');
+    }
+  }
+
+  var args = [a, b, c, d, e];
+  var ii = 0, v;
+  while (args[ii]) {
+    v = args[ii++];
+    for (var k in v) {
+      obj[k] = v[k];
+    }
+
+    // IE ignores toString in object iteration.. See:
+    // webreflection.blogspot.com/2007/07/quick-fix-internet-explorer-and.html
+    if (v.hasOwnProperty && v.hasOwnProperty('toString') &&
+      (typeof v.toString !== 'undefined') && (obj.toString !== v.toString)) {
+      obj.toString = v.toString;
+    }
+  }
+
+  return obj;
+}

package/src/core/replaceTransportMarkers.js

@@ -0,0 +1,27 @@
+import $ from './$';
+
+export default function replaceTransportMarkers(markerValue, markers, key) {
+  const marker = typeof key !== "undefined" ? markers[key] : markers;
+
+  if (Array.isArray(marker)) {
+    for (let i = 0; i < marker.length; i++) {
+      replaceTransportMarkers(markerValue, marker, i);
+    }
+  } else {
+    if (marker && typeof marker == "object") {
+      if (marker.__m) {
+        markers[key] = window.require(marker.__m);
+      } else if (marker.__e) {
+        markers[key] = $(marker.__e);
+      } else if (marker.__map) {
+        markers[key] = new Map(marker.__map);
+      } else if (marker.__set) {
+        markers[key] = new Set(marker.__set);
+      } else {
+        for (let value in marker) {
+          replaceTransportMarkers(markerValue, marker, value);
+        }
+      }
+    }
+  }
+}