marko 5.29.1 → 5.30.0

package/dist/runtime/components/legacy/defineRenderer-legacy.js

@@ -0,0 +1,171 @@
+"use strict";
+var makeRenderable = require("../../renderable");
+var getComponentsContext =
+require("../ComponentsContext").e_;
+var componentLookup = require("@internal/components-util")._o_;
+var modernRenderer = require("../renderer");
+var loader = require("@internal/loader");
+var resolveComponentKey = modernRenderer.aU_;
+
+module.exports = function defineRenderer(renderingLogic) {
+  var renderer = renderingLogic.renderer;
+
+  // eslint-disable-next-line no-constant-condition
+
+
+
+
+  if (renderer && renderer.aV_) {
+    return renderer;
+  }
+
+  var template = renderingLogic.template;
+
+  if (typeof template === "string") {
+    template = loader(template);
+  }
+
+  if (!renderer) {
+    var getInitialProps;
+    var getTemplateData;
+    var getInitialState;
+    var getWidgetConfig;
+    var getInitialBody;
+
+    if (renderingLogic) {
+      getInitialProps = renderingLogic.getInitialProps;
+      getTemplateData = renderingLogic.getTemplateData;
+      getInitialState = renderingLogic.getInitialState;
+      getWidgetConfig = renderingLogic.getWidgetConfig;
+      getInitialBody = renderingLogic.getInitialBody;
+    }
+
+    // Create a renderer function that takes care of translating
+    // the input properties to a view state. Also, this renderer
+    // takes care of re-using existing components.
+    renderer = function renderer(input, out) {
+      var componentsContext = getComponentsContext(out);
+      var globalComponentsContext = componentsContext.f_;
+      var component = globalComponentsContext.ax_;
+      var isReceivingNewInput = !component || component._l_;
+      var parentComponentDef;
+
+      if (component) {
+        component._l_ = false;
+      }
+
+      // Render the template associated with the component using the final template
+      // data that we constructed
+      var newProps = input;
+      var widgetConfig;
+      var widgetState;
+      var widgetBody;
+      var id;
+
+      if (!component && componentLookup) {
+        var key = out.j_;
+
+        if (
+        (parentComponentDef = componentsContext.k_) &&
+        key != null)
+        {
+          id = resolveComponentKey(key.toString(), parentComponentDef);
+        } else if (parentComponentDef) {
+          id = parentComponentDef.aL_();
+        } else {
+          id = globalComponentsContext.aL_();
+        }
+
+        component = componentLookup[id];
+      }
+
+      if (isReceivingNewInput) {
+        // If we do not have state then we need to go through the process
+        // of converting the input to a widget state, or simply normalizing
+        // the input using getInitialProps
+
+        if (getInitialProps) {
+          // This optional method is used to normalize input state
+          newProps = getInitialProps(newProps, out) || {};
+        }
+
+        if (getInitialState) {
+          // This optional method is used to derive the widget state
+          // from the input properties
+          widgetState = getInitialState(newProps, out);
+        }
+
+        if (getInitialBody) {
+          // If we have widget a widget body then pass it to the template
+          // so that it is available to the widget tag and can be inserted
+          // at the w-body marker
+          widgetBody = getInitialBody(newProps, out);
+        } else {
+          // Default to using the nested content as the widget body
+          // getInitialBody was not implemented
+          widgetBody = newProps.renderBody;
+        }
+      } else if (component) {
+        newProps = newProps || component.T_;
+        widgetBody = component._c_;
+        widgetState = component.aA_;
+        widgetConfig = component.widgetConfig;
+      }
+
+      // Use getTemplateData(state, props, out) to get the template
+      // data. If that method is not provided then just use the
+      // the state (if provided) or the input data.
+      var templateData = clone(
+      getTemplateData ?
+      getTemplateData(widgetState, newProps, out) :
+      widgetState || newProps);
+
+
+      if (isReceivingNewInput && getWidgetConfig) {
+        // If getWidgetConfig() was implemented then use that to
+        // get the widget config. The widget config will be passed
+        // to the widget constructor. If rendered on the server the
+        // widget config will be serialized.
+        widgetConfig = getWidgetConfig(newProps, out);
+      }
+      // eslint-disable-next-line no-constant-condition
+
+
+
+
+
+
+
+
+
+
+      templateData.widgetProps = newProps;
+      widgetBody && (templateData.renderBody = widgetBody);
+      widgetState && (templateData.widgetState = widgetState);
+      widgetConfig && (templateData.widgetConfig = widgetConfig);
+
+      template._(templateData, out, id, renderingLogic);
+    };
+  }
+
+  renderer.aV_ = true;
+  renderer.createOut = template ? template.createOut : renderingLogic.createOut;
+  renderer.template = template;
+
+  makeRenderable(renderer, renderer);
+  renderer.render = renderer.render.bind(this);
+
+  return renderer;
+};
+
+function clone(src) {
+  var result = {};
+
+  if (src) {
+    for (var key in src) {
+      result[key] = src[key];
+    }
+  }
+
+  return result;
+}

package/dist/runtime/components/legacy/defineWidget-legacy.js

@@ -0,0 +1 @@
+"use strict";module.exports = require("@internal/components-define-widget-legacy");

package/dist/runtime/components/legacy/dependencies/html.js

@@ -0,0 +1,3 @@
+"use strict";var patch = require("./").patch;
+var Template = require("../../../html").Template;
+patch(Template);

package/dist/runtime/components/legacy/dependencies/index.js

@@ -0,0 +1,178 @@
+"use strict";var nodePath = require("path");
+var defaultResolveFrom = require("resolve-from");
+var env = process.env.NODE_ENV;
+var production = !env || env !== "development";
+
+function getRootDeps(template, context) {
+  if (production && template.aW_) {
+    return template.aW_;
+  }
+
+  attachDepsAndComponentsToTemplate(template, context);
+
+  var deps = template.aW_ = Object.keys(template.aX_).map(
+  (key) => template.aX_[key]);
+
+  var initModule = getInitModule(template.path, template.b_);
+
+  if (initModule) deps.push(initModule);
+
+  // these dependencies should be last
+  deps.concat = function () {
+    var result = [];
+    result = result.concat.apply(result, arguments);
+    result.push.apply(result, this);
+    return result;
+  };
+
+  return deps;
+}
+
+function attachDepsAndComponentsToTemplate(target, context) {
+  var template;
+
+  if (!target.meta && target.template) {
+    template = target.template;
+  } else {
+    template = target;
+  }
+
+  if (typeof template.createOut !== "function") return;
+  if (production && target.aX_) return;
+
+  var deps = target.aX_ = {};
+  var components = target.b_ = {};
+
+  if (!template.meta) {
+    // eslint-disable-next-line no-console
+    console.warn("Metadata not set for template at ", template.path);
+    return;
+  }
+
+  var meta = template.meta;
+  var root = nodePath.dirname(template.path);
+
+  if (meta.deps) {
+    meta.deps.forEach((dep) => {
+      dep = resolveDep(dep, root, context);
+      deps[dep.virtualPath || dep.path] = dep;
+    });
+  }
+
+  if (meta.id && meta.component) {
+    var resolveFrom = context && context.resolveFrom || defaultResolveFrom;
+    components[meta.id] = {
+      id: meta.id,
+      path: resolveFrom(root, meta.component)
+    };
+  }
+
+  if (meta.tags) {
+    meta.tags.forEach((tagPath) => {
+      var resolveFrom = context.resolveFrom || defaultResolveFrom;
+      var tag = resolveFrom(root, tagPath);
+      var ext = nodePath.extname(tag);
+      var req = context.require || require;
+
+      try {
+        tag = req.resolve(tag.slice(0, 0 - ext.length) + ".js");
+      } catch (e) {
+
+        /* ignore error */}
+
+      tag = req(tag);
+
+      attachDepsAndComponentsToTemplate(tag, context);
+
+      if (tag.aX_) Object.assign(deps, tag.aX_);
+      if (tag.b_) Object.assign(components, tag.b_);
+    });
+  }
+}
+
+function getInitModule(path, components) {
+  var module = null;
+
+  if (components) {
+    components = Object.keys(components).map((key) => components[key]);
+
+    if (components.length) {
+      var root = nodePath.dirname(path);
+      var virtualPath = path + ".init.js";
+      var registrations = components.map(
+      (component) =>
+      `components.register('${component.id}', require('.${
+      nodePath.sep
+      }${nodePath.relative(root, component.path)}'));`);
+
+      var code = `
+                var components = require('marko/components');
+                ${registrations.join("\n")}
+            `;
+
+      module = {
+        type: "require",
+        run: true,
+        virtualModule: {
+          path: virtualPath,
+          read: function (_, callback) {
+            // TODO: Check if read can just return string in lasso 2
+            if (callback) {
+              callback(null, code);
+            } else {
+              return code;
+            }
+          }
+        }
+      };
+    }
+  }
+
+  return module;
+}
+
+function resolveDep(dep, root, context) {
+  if (typeof dep === "string") {
+    dep = parseDependencyString(dep);
+  }
+
+  if (dep.path) {
+    var resolveFrom = context && context.resolveFrom || defaultResolveFrom;
+    dep.path = resolveFrom(root, dep.path);
+
+    if (dep.path && !dep.type) {
+      dep.type = dep.path.slice(dep.path.lastIndexOf(".") + 1);
+    }
+  }
+
+  if (dep.virtualPath) {
+    dep.virtualPath = nodePath.resolve(root, dep.virtualPath);
+  }
+
+  if (dep.type === "js") {
+    dep.type = "require";
+    dep.run = true;
+  }
+
+  return dep;
+}
+
+function parseDependencyString(string) {
+  var match = /^(?:([\w-]+)(?::\s*|\s+))?(.*?(?:\.(\w+))?)$/.exec(string);
+  return {
+    type: match[1] || match[3],
+    path: match[2]
+  };
+}
+
+function patch(Template) {
+  Template.prototype.getDependencies = function (context) {
+    context = context || {};
+
+    return getRootDeps(this, context);
+  };
+}
+
+exports.getDeps = getRootDeps;
+exports.resolveDep = resolveDep;
+exports.patch = patch;

package/dist/runtime/components/legacy/dependencies/vdom.js

@@ -0,0 +1,3 @@
+"use strict";var patch = require("./").patch;
+var Template = require("../../../vdom").Template;
+patch(Template);

package/dist/runtime/components/legacy/index.js

@@ -0,0 +1 @@
+"use strict";module.exports = require("@internal/components-entry-legacy");

package/dist/runtime/components/legacy/jquery.js

@@ -0,0 +1,51 @@
+"use strict";var ready = require("./ready");
+
+var idRegExp = /^#(\S+)( .*)?/;
+
+exports.patchComponent = function (jQuery, proto, delayThrow) {
+  if (!(jQuery || (jQuery = window.$)) && !delayThrow) {
+    throw new Error("jQuery not found");
+  }
+
+  (proto || require("../Component").prototype).$ = function jqueryProxy(arg) {
+    var args = arguments;
+    var self = this;
+
+    if (!jQuery) {
+      throw new Error("jQuery not found");
+    }
+
+    if (args.length === 1) {
+      //Handle an "ondomready" callback function
+      if (typeof arg === "function") {
+        return ready(function () {
+          arg.call(self);
+        });
+      } else if (typeof arg === "string") {
+        var match = idRegExp.exec(arg);
+        //Reset the search to 0 so the next call to exec will start from the beginning for the new string
+        if (match != null) {
+          var key = match[1];
+          if (match[2] == null) {
+            return jQuery(self.getEl(key));
+          } else {
+            return jQuery(match[2].trim(), self.getEl(key));
+          }
+        } else {
+          var rootEl = self.getEl();
+          if (!rootEl) {
+            throw new Error("Root element is not defined for component");
+          }
+          if (rootEl) {
+            return jQuery(arg, rootEl);
+          }
+        }
+      }
+    } else if (args.length === 2 && typeof args[1] === "string") {
+      return jQuery(arg, self.getEl(args[1]));
+    } else if (args.length === 0) {
+      return jQuery(self.el);
+    }
+    return jQuery.apply(window, arguments);
+  };
+};

package/dist/runtime/components/legacy/ready.js

@@ -0,0 +1,152 @@
+"use strict"; /*
+    jQuery's doc.ready/$(function(){}) should
+    you wish to use a cross-browser domReady solution
+    without opting for a library.
+
+    Demo: http://jsfiddle.net/zKLpb/
+
+    usage:
+    $(function(){
+        // your code
+    });
+
+    Parts: jQuery project, Diego Perini, Lucent M.
+    Previous version from Addy Osmani (https://raw.github.com/addyosmani/jquery.parts/master/jquery.documentReady.js)
+
+    This version: Patrick Steele-Idem
+    - Converted to CommonJS module
+    - Code cleanup
+    - Fixes for IE <=10
+*/
+
+var isReady = false;
+var readyBound = false;
+
+var defaultWindow = typeof window != "undefined" && window;
+var defaultDocument = typeof document != "undefined" && document;
+
+var listeners = [];
+
+function domReadyCallback() {
+  for (var i = 0, len = listeners.length; i < len; i++) {
+    var listener = listeners[i];
+    listener[0].call(listener[1]);
+  }
+  listeners = null;
+}
+
+function bindReady(doc) {
+  var toplevel = false;
+  var win = doc.defaultView || defaultWindow || doc;
+
+  // Handle when the DOM is ready
+  function domReady() {
+    // Make sure that the DOM is not already loaded
+    if (!isReady) {
+      // Make sure body exists, at least, in case IE gets a little overzealous (ticket #5443).
+      if (!doc.body) {
+        return setTimeout(domReady, 1);
+      }
+      // Remember that the DOM is ready
+      isReady = true;
+      // If there are functions bound, to execute
+      domReadyCallback();
+      // Execute all of them
+    }
+  } // /ready()
+
+  // The ready event handler
+  function domContentLoaded() {
+    if (doc.addEventListener) {
+      doc.removeEventListener("DOMContentLoaded", domContentLoaded, false);
+      doc.removeEventListener("load", domContentLoaded, false);
+    } else {
+      // we're here because readyState !== "loading" in oldIE
+      // which is good enough for us to call the dom ready!
+      doc.detachEvent("onreadystatechange", domContentLoaded);
+      doc.detachEvent("onload", domContentLoaded);
+    }
+    domReady();
+  }
+
+  // The DOM ready check for Internet Explorer
+  function doScrollCheck() {
+    if (isReady) {
+      return;
+    }
+
+    try {
+      // If IE is used, use the trick by Diego Perini
+      // http://javascript.nwbox.com/IEContentLoaded/
+      doc.documentElement.doScroll("left");
+    } catch (error) {
+      setTimeout(doScrollCheck, 1);
+      return;
+    }
+    // and execute any waiting functions
+    domReady();
+  }
+
+  // Catch cases where $ is called after the
+  // browser event has already occurred. IE <= 10 has a bug that results in 'interactive' being assigned
+  // to the readyState before the DOM is really ready
+  if (
+  document.attachEvent ?
+  document.readyState === "complete" :
+  document.readyState !== "loading")
+  {
+    // We will get here if the browser is IE and the readyState === 'complete' or the browser
+    // is not IE and the readyState === 'interactive' || 'complete'
+    domReady(doc);
+  } else if (doc.addEventListener) {
+    // Standards-based browsers support DOMContentLoaded
+    // Use the handy event callback
+    doc.addEventListener("DOMContentLoaded", domContentLoaded, false);
+    // A fallback to win.onload, that will always work
+    win.addEventListener("load", domContentLoaded, false);
+    // If IE event model is used
+  } else if (doc.attachEvent) {
+    // ensure firing before onload,
+    // maybe late but safe also for iframes
+    doc.attachEvent("onreadystatechange", domContentLoaded);
+    // A fallback to win.onload, that will always work
+    win.attachEvent("onload", domContentLoaded);
+    // If IE and not a frame
+    // continually check to see if the document is ready
+    try {
+      toplevel = win.frameElement == null;
+    } catch (e) {
+
+      /* ignore error */}
+    if (doc.documentElement.doScroll && toplevel) {
+      doScrollCheck();
+    }
+  }
+}
+
+function ready(callback, thisObj, doc) {
+  if (isReady) {
+    return callback.call(thisObj);
+  }
+
+  listeners.push([callback, thisObj]);
+
+  if (!readyBound) {
+    readyBound = true;
+    bindReady(doc || defaultDocument);
+  }
+}
+
+module.exports = ready;
+
+module.exports.patchComponent = function (proto) {
+  if (proto && proto.ready) {
+    // Don't patch if the component has overwritten the ready method.
+    return;
+  }
+
+  (proto || require("../Component").prototype).ready = function (callback) {
+    var document = this.el.ownerDocument;
+    ready(callback, this, document);
+  };
+};