marko 5.29.2 → 5.30.1

package/README.md

@@ -83,7 +83,7 @@ export default {
   },
   increment() {
     this.state.count++;
-  }
+  },
 };
 ```
 

package/bin/markoc.js

@@ -25,7 +25,7 @@ var appModulePath = require("app-module-path");
 var mmOptions = {
   matchBase: true,
   dot: true,
-  flipNegate: true
+  flipNegate: true,
 };
 
 function relPath(path) {
@@ -38,55 +38,55 @@ var args = require("argly")
   .createParser({
     "--help": {
       type: "boolean",
-      description: "Show this help message"
+      description: "Show this help message",
     },
     "--files --file -f *": {
       type: "string[]",
-      description: "A set of directories or files to compile"
+      description: "A set of directories or files to compile",
     },
     "--ignore -i": {
       type: "string[]",
-      description: 'An ignore rule (default: --ignore "/node_modules" ".*")'
+      description: 'An ignore rule (default: --ignore "/node_modules" ".*")',
     },
     "--clean -c": {
       type: "boolean",
-      description: "Clean all of the *.marko.js files"
+      description: "Clean all of the *.marko.js files",
     },
     "--force": {
       type: "boolean",
-      description: "Force template recompilation even if unchanged"
+      description: "Force template recompilation even if unchanged",
     },
     "--paths -p": {
       type: "string[]",
       description:
-        "Additional directories to add to the Node.js module search path"
+        "Additional directories to add to the Node.js module search path",
     },
     "--quiet -q": {
       type: "boolean",
-      description: "Only print warnings and errors"
+      description: "Only print warnings and errors",
     },
     "--migrate -m": {
       type: "boolean",
       description:
-        "Run any migrations that exist for the provided template and write changes to disk"
+        "Run any migrations that exist for the provided template and write changes to disk",
     },
     "--strip-types -t": {
       type: "boolean",
-      description: "Strip all type information from the compiled template"
+      description: "Strip all type information from the compiled template",
     },
     "--browser -b": {
       type: "boolean",
-      description: "Browser output"
+      description: "Browser output",
     },
     "--source-maps -s": {
       type: "string",
       description:
-        "Output a sourcemap beside the compiled file. (use --source-maps inline for an inline source map)"
+        "Output a sourcemap beside the compiled file. (use --source-maps inline for an inline source map)",
     },
     "--version -v": {
       type: "boolean",
-      description: "Print markoc and marko compiler versions to the console"
-    }
+      description: "Print markoc and marko compiler versions to the console",
+    },
   })
   .usage("Usage: $0 <pattern> [options]")
   .example("Compile a single template", "$0 template.marko")
@@ -143,7 +143,7 @@ var compileOptions = {
   stripTypes: args.stripTypes,
   sourceMaps: args.sourceMaps || false,
   compilerType: "markoc",
-  compilerVersion: markoPkgVersion || markocPkgVersion
+  compilerVersion: markoPkgVersion || markocPkgVersion,
 };
 
 var force = args.force;
@@ -242,7 +242,7 @@ function walk(files, options, done) {
           done(null);
         }
       }
-    }
+    },
   };
 
   function doWalk(dir) {
@@ -316,7 +316,7 @@ if (args.clean) {
             context.endAsync();
           });
         }
-      }
+      },
     },
     function () {
       if (deleteCount === 0) {
@@ -420,7 +420,7 @@ if (args.clean) {
           ) {
             compile(file, context);
           }
-        }
+        },
       },
       function (err) {
         if (err) {

package/dist/core-tags/core/await/renderer.js

@@ -220,7 +220,11 @@ function renderContents(err, data, input, out) {
   if (err) {
     if (input.catch) {
       if (errorRenderer) {
-        errorRenderer(out, err);
+        try {
+          errorRenderer(out, err);
+        } catch (err2) {
+          out.error(err2);
+        }
       }
     } else {
       out.error(err);

package/dist/node_modules/@internal/components-beginComponent/index.js

@@ -4,6 +4,7 @@ const ComponentDef = require("../../../runtime/components/ComponentDef");
 
 var FLAG_WILL_RERENDER_IN_BROWSER = 1;
 // var FLAG_HAS_RENDER_BODY = 2;
+var FLAG_OLD_HYDRATE_NO_CREATE = 8;
 
 module.exports = function beginComponent(
 componentsContext,
@@ -11,14 +12,19 @@ component,
 key,
 ownerComponentDef,
 isSplitComponent,
-isImplicitComponent)
+isImplicitComponent,
+existingComponentDef)
 {
   var componentId = component.id;
 
-  var componentDef = componentsContext.k_ = new ComponentDef(
+  // existingComponentDef is only here to allow binding a conditional
+  // widget.  It should be removed when the legacy compat layer is removed.
+  var componentDef =
+  existingComponentDef || (
+  componentsContext.k_ = new ComponentDef(
   component,
   componentId,
-  componentsContext);
+  componentsContext));
 
 
   var ownerIsRenderBoundary =
@@ -54,6 +60,10 @@ isImplicitComponent)
     componentsContext.p_ = false;
   }
 
+  if (out.global.oldHydrateNoCreate === true) {
+    componentDef.C_ |= FLAG_OLD_HYDRATE_NO_CREATE;
+  }
+
   if ((ownerIsRenderBoundary || ownerWillRerender) && key != null) {
     out.w(
     "<!--" +

package/dist/node_modules/@internal/components-define-widget-legacy/index-browser.js

@@ -0,0 +1,331 @@
+"use strict";
+/* jshint newcap:false */
+
+var BaseState;
+var BaseComponent;
+var inherit;
+var loader = require("@internal/loader");
+var registry = require("@internal/components-registry");
+var jQuery = require("../../../runtime/components/legacy/jquery");
+var ready = require("../../../runtime/components/legacy/ready");
+
+
+var stateToJSONDef = {
+  enumerable: false,
+  value: function returnSelf() {
+    return this;
+  }
+};
+function noop() {}
+
+module.exports = function defineWidget(def, renderer) {
+  def = def.Widget || def;
+
+  if (def.E_) {
+    return def;
+  }
+
+  var ComponentClass = function () {};
+  var proto;
+  var legacyInit;
+
+  if (typeof def === "function") {
+    proto = def.prototype;
+    legacyInit = def;
+  } else if (typeof def === "object") {
+    proto = def;
+    legacyInit = def.init;
+  } else {
+    throw TypeError();
+  }
+
+  ComponentClass.prototype = proto;
+
+  // We don't use the constructor provided by the user
+  // since we don't invoke their constructor until
+  // we have had a chance to do our own initialization.
+  // Instead, we store their constructor in the "initComponent"
+  // property and that method gets called later inside
+  // init-components-browser.js
+  function Component(id, doc) {
+    BaseComponent.call(this, id, doc);
+  }
+
+  if (!proto.E_) {
+    // Inherit from Component if they didn't already
+    ComponentClass.prototype = Object.create(BaseComponent.prototype);
+    for (var propName in proto) {
+      if (proto.hasOwnProperty(propName)) {
+        ComponentClass.prototype[propName] = proto[propName];
+      }
+    }
+  }
+
+  // The same prototype will be used by our constructor after
+  // we he have set up the prototype chain using the inherit function
+  proto = Component.prototype = ComponentClass.prototype;
+  proto.F_ = true;
+
+  proto.constructor = def.constructor = Component;
+
+  Object.defineProperty(proto, "state", {
+    get: function () {
+      var raw = this.G_ && this.G_.H_;
+
+      if (raw && !raw.toJSON) {
+        Object.defineProperty(this.G_.H_, "toJSON", stateToJSONDef);
+      }
+
+      return raw;
+    },
+    set: function (newState) {
+      newState = newState || {};
+      // eslint-disable-next-line no-constant-condition
+
+
+
+
+
+
+
+
+
+
+
+
+      this.setState(newState);
+    }
+  });
+
+  Object.defineProperty(proto, "__document", {
+    get: function () {
+      // eslint-disable-next-line no-constant-condition
+
+
+
+      return this.I_;
+    }
+  });
+
+  Object.defineProperty(proto, "el", {
+    get: function () {
+      // eslint-disable-next-line no-constant-condition
+
+
+
+
+
+
+
+
+
+
+
+      return this.J_;
+    }
+  });
+
+  // get legacy methods
+
+  proto.K_ = proto.onRender;
+  Object.defineProperty(proto, "onRender", {
+    get: noop,
+    set: function (v) {
+      proto.K_ = v;
+    }
+  });
+
+  proto.L_ = proto.onUpdate;
+  Object.defineProperty(proto, "onUpdate", {
+    get: function () {
+      return modernMountOrUpdate;
+    },
+    set: function (v) {
+      proto.L_ = v;
+    }
+  });
+
+  proto.M_ = proto.onDestroy;
+  Object.defineProperty(proto, "onDestroy", {
+    get: function () {
+      return modernOnDestory;
+    },
+    set: function (v) {
+      proto.M_ = v;
+    }
+  });
+
+  proto.getWidget = proto.getComponent;
+  proto.getWidgets = proto.getComponents;
+  proto.onMount = modernMountOrUpdate;
+
+  if (legacyInit) {
+    proto.N_ = legacyInit;
+  }
+
+  // convert legacy to modern
+  proto.O_ = proto.update;
+  proto.update = function () {
+    if (this.P_) {
+      // eslint-disable-next-line no-constant-condition
+
+
+
+
+
+
+
+
+
+      this.destroy = modernOnDestory;
+      this.P_ = false;
+    }
+    this.Q_ = true;
+    if (this.J_) {
+      this.onBeforeUpdate && this.onBeforeUpdate();
+    }
+
+    this.O_();
+    this.Q_ = false;
+  };
+
+  function modernMountOrUpdate() {
+    var self = this;
+    var el = this.l_["@_wbind"];
+    var prevEl = this.J_;
+
+    if (prevEl !== el) {
+      this.J_ = el;
+
+      if (prevEl) {
+        this.onBeforeDestroy && this.onBeforeDestroy();
+        this.M_ && this.M_();
+        this.R_ = undefined;
+        this.removeAllListeners();
+      }
+
+      if (el) {
+        this.N_ && this.N_(this.widgetConfig || {});
+        this.K_ && this.K_({ firstRender: true });
+        this.R_ = legacyRender;
+
+        // eslint-disable-next-line no-constant-condition
+
+
+
+
+
+
+
+
+
+        el.__widget = this;
+
+      }
+    } else if (el) {
+      if (prevEl) {
+        this.L_ && this.L_();
+      }
+
+      if (this.S_) {
+        this.K_ &&
+        this.K_({ firstRender: false });
+      }
+    }
+
+    this.T_ = this.U_;
+    this.U_ = null;
+    this.S_ = false;
+  }
+
+  function legacyRender() {
+    if (!this.Q_) {
+      this.onBeforeUpdate && this.onBeforeUpdate();
+    }
+
+    this.S_ = true;
+  }
+
+  function modernOnDestory() {
+    if (this.J_) {
+      this.onBeforeDestroy && this.onBeforeDestroy();
+      this.M_ && this.M_();
+      this.J_ = null;
+    }
+  }
+
+  // Set a flag on the constructor function to make it clear this is
+  // a component so that we can short-circuit this work later
+  Component.E_ = true;
+
+  function State() {
+    BaseState.apply(this, arguments);
+  }
+  inherit(State, BaseState);
+  proto.V_ = State;
+
+  jQuery.patchComponent(
+  window.$,
+  proto,
+  true /* don't throw error until used if `$` is missing*/);
+
+
+  ready.patchComponent(proto);
+
+  if (!renderer) {
+    renderer = ComponentClass.renderer || ComponentClass.prototype.renderer;
+    if (renderer) {
+      // Legacy support
+      var createOut = renderer.createOut;
+      if (typeof renderer !== "function") {
+        var rendererObject = renderer;
+        renderer = function (input, out) {
+          var rendererFunc = rendererObject.renderer || rendererObject.render;
+          rendererFunc(input, out);
+        };
+        renderer.createOut = createOut;
+      }
+
+      renderer.render = function (input) {
+        var out = createOut();
+        renderer(input, out);
+        return out.end();
+      };
+    }
+  }
+
+  if (renderer) {
+    // Add the rendering related methods as statics on the
+    // new component constructor function
+    Component.renderer = proto.W_ = renderer;
+    Component.render = renderer.render;
+    Component.renderSync = renderer.renderSync;
+  }
+
+  // eslint-disable-next-line no-constant-condition
+
+
+
+
+
+
+
+
+  Component._isWidget = true;
+
+
+  var template = def.template;
+  if (template) {
+    if (typeof template === "string") {
+      template = loader(template);
+    }
+
+    registry.r(template.X_, function () {return Component;});
+  }
+
+  return Component;
+};
+
+BaseState = require("../../../runtime/components/State");
+BaseComponent = require("../../../runtime/components/Component");
+inherit = require("raptor-util/inherit");

package/dist/node_modules/@internal/components-define-widget-legacy/index.js

@@ -0,0 +1,18 @@
+"use strict";module.exports = function defineWidget(def, renderer) {
+  if (def.E_) {
+    return def;
+  }
+
+  if (renderer) {
+    return {
+      E_: true,
+      _isWidget: true,
+      renderer: renderer,
+      render: renderer.render,
+      renderSync: renderer.renderSync,
+      template: renderer.template
+    };
+  } else {
+    return { E_: true, _isWidget: true };
+  }
+};

package/dist/node_modules/@internal/components-define-widget-legacy/package.json

@@ -0,0 +1,11 @@
+{
+  "main": "./index.js",
+  "browser": "./index-browser.js",
+  "exports": {
+    ".": {
+      "worker": "./index.js",
+      "browser": "./index-browser.js",
+      "default": "./index.js"
+    }
+  }
+}

package/dist/node_modules/@internal/components-entry/index-browser.js

@@ -1,7 +1,7 @@
 "use strict";var registry = require("@internal/components-registry");
 
-exports.getComponentForEl = require("@internal/components-util").E_;
-exports.init = registry.F_;
+exports.getComponentForEl = require("@internal/components-util").Y_;
+exports.init = registry.Z_;
 exports.register = function (id, component) {
   registry.r(id, function () {
     return component;