bigpipe-util 0.2.13 → 0.2.14

package/dist/Primer.js

@@ -0,0 +1,117 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = Primer;
+var _AsyncRequest = _interopRequireDefault(require("./async/AsyncRequest"));
+var _Parent = require("./core/Parent");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+function Primer() {
+  const rootElement = document.documentElement;
+  const RELATIONSHIP_REGEX = /async(?:-post)?|dialog/;
+  rootElement.addEventListener('click', function (event) {
+    event = event || window.event;
+    const elementOnClicked = event.target || event.srcElement;
+    const linkNodeOnClicked = (0, _Parent.byTag)(elementOnClicked, 'A');
+    if (!linkNodeOnClicked) {
+      return;
+    }
+    const ajaxHref = linkNodeOnClicked.getAttribute('ajaxify');
+    const realHref = linkNodeOnClicked.href;
+    let relationship = linkNodeOnClicked.rel && linkNodeOnClicked.rel.match(RELATIONSHIP_REGEX);
+    relationship = relationship && relationship[0];
+    if (ajaxHref && realHref && !/#$/.test(realHref)) {
+      const isMiddleMouseButton = event.which && event.which === 2;
+      const hasModifierKey = event.altKey || event.ctrlKey || event.metaKey || event.shiftKey;
+      if (isMiddleMouseButton || hasModifierKey) {
+        return;
+      }
+    }
+    if (linkNodeOnClicked.classList.contains('async-saving')) {
+      event.preventDefault();
+      return;
+    }
+    switch (relationship) {
+      case 'async':
+      case 'async-post':
+        event.preventDefault();
+        new _AsyncRequest.default(ajaxHref).setRelative(linkNodeOnClicked).setInitialHandler(() => {
+          linkNodeOnClicked.classList.add('async-saving');
+        }).setHandler(() => {
+          linkNodeOnClicked.classList.remove('async-saving');
+        }).setErrorHandler(() => {
+          linkNodeOnClicked.classList.remove('async-saving');
+        }).setMethod(relationship === 'async-post' ? 'POST' : 'GET').send();
+        break;
+      case 'dialog':
+        event.preventDefault();
+        new _AsyncRequest.default(linkNodeOnClicked.getAttribute('ajaxify')).setRelative(linkNodeOnClicked).setInitialHandler(() => {
+          linkNodeOnClicked.classList.add('async-saving');
+        }).setHandler(() => {
+          linkNodeOnClicked.classList.remove('async-saving');
+        }).setErrorHandler(() => {
+          linkNodeOnClicked.classList.remove('async-saving');
+        }).setMethod('POST').send();
+        break;
+    }
+  });
+  rootElement.addEventListener('submit', function (event) {
+    event = event || window.event;
+    const eventTarget = event.target || event.srcElement;
+    if (eventTarget && eventTarget.nodeName === 'FORM' && eventTarget.getAttribute('rel') === 'async') {
+      event.preventDefault();
+      const formData = new FormData(eventTarget);
+      const submitter = event.submitter || eventTarget.querySelector("button[type='submit']");
+      const activeControls = eventTarget.querySelectorAll('input:not([readonly]),select:not([readonly]),textarea:not([readonly])');
+      if (submitter && submitter.name) {
+        formData.append(submitter.name, submitter.value);
+      }
+      new _AsyncRequest.default(eventTarget.getAttribute('ajaxify') || eventTarget.getAttribute('action')).setMethod(eventTarget.method || 'POST').setRelative(eventTarget).setData(formData).setInitialHandler(function () {
+        eventTarget.classList.add('async-saving');
+        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 () {
+        eventTarget.classList.remove('async-saving');
+        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 () {
+        eventTarget.classList.remove('async-saving');
+        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');
+          }
+        }
+      }).send();
+    }
+  });
+}

package/{src → dist}/ServerJS.js

@@ -1,40 +1,40 @@
-import replaceTransportMarkers from "./core/replaceTransportMarkers";
-
-function handler(dependencies, guard, context) {
-  return dependencies.map(function (args) {
-    return 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 || []));
-    }
-  }
-}
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _replaceTransportMarkers = _interopRequireDefault(require("./core/replaceTransportMarkers"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+function handler(dependencies, guard, context) {
+  return dependencies.map(function (args) {
+    return guard.apply(context, args);
+  });
+}
+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) {
+        (0, _replaceTransportMarkers.default)(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) {
+        (0, _replaceTransportMarkers.default)(this._relativeTo, marker);
+      }
+      new (window.require(modulePath))(...(marker || []));
+    }
+  }
+}
+exports.default = ServerJS;

package/dist/async/AsyncDOM.js

@@ -0,0 +1,58 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _DOM = _interopRequireDefault(require("../core/DOM"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+class AsyncDOM {
+  invoke(domOps, element) {
+    for (let i = 0; i < domOps.length; ++i) {
+      let [type, selector, enableTarget, content] = domOps[i];
+      let node = enableTarget && element || null;
+      if (selector) {
+        node = (node || document.documentElement).querySelector(selector);
+      }
+      if (!node) {
+        if (typeof __DEV__ !== 'undefined' && __DEV__) {
+          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.default.setContent(node, content.__html);
+          break;
+        case 'appendContent':
+          _DOM.default.appendContent(node, content.__html);
+          break;
+        case 'prependContent':
+          _DOM.default.prependContent(node, content.__html);
+          break;
+        case 'insertAfter':
+          _DOM.default.insertAfter(node, content.__html);
+          break;
+        case 'insertBefore':
+          _DOM.default.insertBefore(node, content.__html);
+          break;
+        case 'remove':
+          _DOM.default.remove(node);
+          break;
+        case 'replace':
+          _DOM.default.replace(node, content.__html);
+          break;
+      }
+    }
+  }
+}
+exports.default = AsyncDOM;

package/{src → dist}/async/AsyncRequest.js

@@ -1,210 +1,182 @@
-import emptyFunction from "fbjs/lib/emptyFunction";
-import AsyncResponse from "./AsyncResponse";
-
-let requests = 0;
-
-export function incrementRequests() {
-  return requests++;
-}
-
-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 finallyHandler = 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 = JSON.parse(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);
-      }
-
-      finallyHandler(this);
-    }
-
-    request.setRequestHeader("X-Requested-With", "XMLHttpRequest");
-
-    incrementRequests();
-
-    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;
-  }
-};
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+exports.incrementRequests = incrementRequests;
+var _emptyFunction = _interopRequireDefault(require("fbjs/lib/emptyFunction"));
+var _AsyncResponse = _interopRequireDefault(require("./AsyncResponse"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+let requests = 0;
+function incrementRequests() {
+  return requests++;
+}
+function serialize(obj, prefix) {
+  const str = [];
+  for (const p in obj) {
+    if (Object.prototype.hasOwnProperty.call(obj, 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;
+}
+class AsyncRequest {
+  constructor(uri) {
+    this.method = 'POST';
+    this.uri = '';
+    this.relative = null;
+    this.data = {};
+    this.headers = {};
+    this.initialHandler = _emptyFunction.default;
+    this.handler = null;
+    this.finallyHandler = _emptyFunction.default;
+    this.errorHandler = _emptyFunction.default;
+    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.default;
+  }
+  setHandler(fn) {
+    if (validateResponseHandler(fn)) {
+      this.handler = fn;
+    }
+    return this;
+  }
+  setFinallyHandler(fn) {
+    this.finallyHandler = fn;
+    return this;
+  }
+  getFinallyHandler() {
+    return this.finallyHandler || _emptyFunction.default;
+  }
+  getHandler() {
+    return this.handler || _emptyFunction.default;
+  }
+  setErrorHandler(fn) {
+    if (validateResponseHandler(fn)) {
+      this.errorHandler = fn;
+    }
+    return this;
+  }
+  getErrorHandler() {
+    return this.errorHandler || _emptyFunction.default;
+  }
+  abort() {
+    const {
+      transport
+    } = this;
+    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 finallyHandler = 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 = JSON.parse(safeJson);
+        } catch (e) {
+          throw new Error('Failed to handle response: ' + e.message + '\n' + this.responseText);
+        }
+        new _AsyncResponse.default().handle(response, self.relative);
+        handler(response);
+      } else {
+        errorHandler(this);
+      }
+      finallyHandler(this);
+    };
+    request.setRequestHeader('X-Requested-With', 'XMLHttpRequest');
+    incrementRequests();
+    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 = function () {
+      errorHandler(this);
+      finallyHandler(this);
+    };
+    request.send(data);
+    return request;
+  }
+}
+exports.default = AsyncRequest;