bigpipe-util 0.2.5 → 0.2.7

package/src/ServerJS.js

@@ -1,40 +1,40 @@
-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 factory = window.require(modulePath);
-      const context = typeof factory === 'function' ? new factory : factory;
-
-      if (!context[method]) {
-        throw new TypeError(`Module ${modulePath} has no method "${method}"`);
-      }
-
-      context[method].apply(context, marker || []);
-    } else {
-      if (marker) {
-        replaceTransportMarkers(this._relativeTo, marker);
-      }
-
-      new (window.require(modulePath))(...(marker || []));
-    }
-  }
-}
+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 factory = window.require(modulePath);
+      const context = typeof factory === 'function' ? new factory : factory;
+
+      if (!context[method]) {
+        throw new TypeError(`Module ${modulePath} has no method "${method}"`);
+      }
+
+      context[method].apply(context, marker || []);
+    } else {
+      if (marker) {
+        replaceTransportMarkers(this._relativeTo, marker);
+      }
+
+      new (window.require(modulePath))(...(marker || []));
+    }
+  }
+}

package/src/async/AsyncDOM.js

@@ -1,56 +1,56 @@
-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);
-      }
-
-      if (!node) {
-        console.error(`Selector '${selector}' does not match anything!`)
-        continue;
-      }
-
-      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);
-      }
-    }
-  }
-};
+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);
+      }
+
+      if (!node) {
+        console.error(`Selector '${selector}' does not match anything!`)
+        continue;
+      }
+
+      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

@@ -1,206 +1,206 @@
-import emptyFunction from "fbjs/lib/emptyFunction";
-import AsyncResponse from "./AsyncResponse";
-
-let requests = 0;
-
-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 class AsyncRequest {
-  constructor(uri) {
-    this.method = "POST";
-    this.uri = "";
-    this.relative = null;
-    this.data = {};
-    this.headers = {};
-    this.initialHandler = emptyFunction;
-    this.handler = null;
-    this.finallyHandler = emptyFunction;
-    this.errorHandler = emptyFunction;
-
-    if (uri !== undefined) {
-      this.setURI(uri);
-    }
-  }
-
-  setMethod(method) {
-    this.method = method.toString().toUpperCase();
-    return this;
-  }
-
-  getMethod() {
-    return this.method;
-  }
-
-  setRelative(relative) {
-    this.relative = relative;
-    return this;
-  }
-
-  getRelative() {
-    return this.relative;
-  }
-
-  setData(obj) {
-    this.data = obj;
-    return this;
-  }
-
-  getData() {
-    return this.data;
-  }
-
-  setRequestHeader(name, value) {
-    this.headers[name] = value;
-    return this;
-  }
-
-  setURI(uri) {
-    this.uri = uri;
-
-    return this;
-  }
-  getURI() {
-    return this.uri;
-  }
-
-  setInitialHandler(fn) {
-    this.initialHandler = fn;
-    return this;
-  }
-
-  getInitialHandler() {
-    return this.initialHandler || emptyFunction;
-  }
-
-  setHandler(fn) {
-    if (validateResponseHandler(fn)) {
-      this.handler = fn;
-    }
-    return this;
-  }
-
-  setFinallyHandler(fn) {
-    this.finallyHandler = fn;
-    return this;
-  }
-
-  getFinallyHandler() {
-    return this.finallyHandler || emptyFunction;
-  }
-
-  getHandler() {
-    return this.handler || emptyFunction;
-  }
-
-  setErrorHandler(fn) {
-    if (validateResponseHandler(fn)) {
-      this.errorHandler = fn;
-    }
-    return this;
-  }
-
-  getErrorHandler() {
-    return this.errorHandler || emptyFunction;
-  }
-
-  abort() {
-    const transport = this.transport;
-
-    if (transport) {
-      transport.abort();
-    }
-  }
-
-  _unshieldResponseText(text) {
-    const shield = "for (;;);";
-    const shieldLength = shield.length;
-
-    if (text.length <= shieldLength) {
-      throw new Error("Response too short on async to " + this.getURI());
-    }
-
-    return text.substring(shieldLength);
-  }
-
-  send() {
-    const {uri, method} = this;
-    let { data } = this;
-
-    const handler = this.getHandler();
-    const errorHandler = this.getErrorHandler();
-    const initialHandler = this.getInitialHandler();
-    const getFinallyHandler = this.getFinallyHandler();
-
-    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 {
-          const safeJson = self._unshieldResponseText(this.responseText);
-          response = eval("(" + safeJson + ")");
-        } 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);
-      }
-
-      getFinallyHandler(this);
-    }
-
-    request.setRequestHeader("X-Requested-With", "XMLHttpRequest");
-
-    requests++;
-
-    if (data instanceof FormData) {
-      data.append('__req', requests);
-    } else {
-      data.__req = requests;
-      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;
-  }
-};
+import emptyFunction from "fbjs/lib/emptyFunction";
+import AsyncResponse from "./AsyncResponse";
+
+let requests = 0;
+
+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 class AsyncRequest {
+  constructor(uri) {
+    this.method = "POST";
+    this.uri = "";
+    this.relative = null;
+    this.data = {};
+    this.headers = {};
+    this.initialHandler = emptyFunction;
+    this.handler = null;
+    this.finallyHandler = emptyFunction;
+    this.errorHandler = emptyFunction;
+
+    if (uri !== undefined) {
+      this.setURI(uri);
+    }
+  }
+
+  setMethod(method) {
+    this.method = method.toString().toUpperCase();
+    return this;
+  }
+
+  getMethod() {
+    return this.method;
+  }
+
+  setRelative(relative) {
+    this.relative = relative;
+    return this;
+  }
+
+  getRelative() {
+    return this.relative;
+  }
+
+  setData(obj) {
+    this.data = obj;
+    return this;
+  }
+
+  getData() {
+    return this.data;
+  }
+
+  setRequestHeader(name, value) {
+    this.headers[name] = value;
+    return this;
+  }
+
+  setURI(uri) {
+    this.uri = uri;
+
+    return this;
+  }
+  getURI() {
+    return this.uri;
+  }
+
+  setInitialHandler(fn) {
+    this.initialHandler = fn;
+    return this;
+  }
+
+  getInitialHandler() {
+    return this.initialHandler || emptyFunction;
+  }
+
+  setHandler(fn) {
+    if (validateResponseHandler(fn)) {
+      this.handler = fn;
+    }
+    return this;
+  }
+
+  setFinallyHandler(fn) {
+    this.finallyHandler = fn;
+    return this;
+  }
+
+  getFinallyHandler() {
+    return this.finallyHandler || emptyFunction;
+  }
+
+  getHandler() {
+    return this.handler || emptyFunction;
+  }
+
+  setErrorHandler(fn) {
+    if (validateResponseHandler(fn)) {
+      this.errorHandler = fn;
+    }
+    return this;
+  }
+
+  getErrorHandler() {
+    return this.errorHandler || emptyFunction;
+  }
+
+  abort() {
+    const transport = this.transport;
+
+    if (transport) {
+      transport.abort();
+    }
+  }
+
+  _unshieldResponseText(text) {
+    const shield = "for (;;);";
+    const shieldLength = shield.length;
+
+    if (text.length <= shieldLength) {
+      throw new Error("Response too short on async to " + this.getURI());
+    }
+
+    return text.substring(shieldLength);
+  }
+
+  send() {
+    const {uri, method} = this;
+    let { data } = this;
+
+    const handler = this.getHandler();
+    const errorHandler = this.getErrorHandler();
+    const initialHandler = this.getInitialHandler();
+    const getFinallyHandler = this.getFinallyHandler();
+
+    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 {
+          const safeJson = self._unshieldResponseText(this.responseText);
+          response = eval("(" + safeJson + ")");
+        } 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);
+      }
+
+      getFinallyHandler(this);
+    }
+
+    request.setRequestHeader("X-Requested-With", "XMLHttpRequest");
+
+    requests++;
+
+    if (data instanceof FormData) {
+      data.append('__req', requests);
+    } else {
+      data.__req = requests;
+      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

@@ -1,21 +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);
-      }
-    }
-  }
-};
+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

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