basic-element-base - npm Package Compare versions

Comparing version 0.0.3 to 0.7.0

dist/basic-element-base.js

@@ -92,4 +92,2 @@ (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){
 
-var _get = function get(object, property, receiver) { if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { return get(parent, property, receiver); } } else if ("value" in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } };
-
 Object.defineProperty(exports, "__esModule", {
@@ -106,69 +104,2 @@ value: true
 /**
- * @class AutomaticNodeFinding
- * @classdesc Mixin to create references to elements in a component's Shadow
- * DOM subtree
- *
- * This adds a member on the component called `$` that can be used to reference
- * elements with IDs. E.g., if component's shadow contains an element
- * `<button id="foo">`, then this mixin will create a member `this.$.foo` that
- * points to that button. Such references simplify a component's access to its
- * own elements.
- *
- * This trades off a one-time cost of querying all elements in the shadow tree
- * against having to query for an element each time the component wants to
- * inspect or manipulate it.
- *
- * This mixin is inspired by Polymer's automatic node finding feature.
- * See https://www.polymer-project.org/1.0/docs/devguide/local-dom.html#node-finding.
- */
-
-exports.default = function (base) {
-  return function (_base) {
-    _inherits(AutomaticNodeFinding, _base);
-
-    function AutomaticNodeFinding() {
-      _classCallCheck(this, AutomaticNodeFinding);
-
-      return _possibleConstructorReturn(this, Object.getPrototypeOf(AutomaticNodeFinding).apply(this, arguments));
-    }
-
-    _createClass(AutomaticNodeFinding, [{
-      key: 'createdCallback',
-      value: function createdCallback() {
-        var _this2 = this;
-
-        if (_get(Object.getPrototypeOf(AutomaticNodeFinding.prototype), 'createdCallback', this)) {
-          _get(Object.getPrototypeOf(AutomaticNodeFinding.prototype), 'createdCallback', this).call(this);
-        }
-        if (this.shadowRoot) {
-          this.$ = {};
-          var nodesWithIds = this.shadowRoot.querySelectorAll('[id]');
-          [].forEach.call(nodesWithIds, function (node) {
-            var id = node.getAttribute('id');
-            _this2.$[id] = node;
-          });
-        }
-      }
-    }]);
-
-    return AutomaticNodeFinding;
-  }(base);
-};
-
-},{}],3:[function(require,module,exports){
-'use strict';
-
-var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
-
-function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
-
-/**
  * @class Composable
@@ -284,2 +215,117 @@ * @classdesc Mixin to make a class more easily composable with other mixins
 
+},{}],3:[function(require,module,exports){
+"use strict";
+
+var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
+
+/**
+ * @class DistributedChildren
+ * @classdesc Mixin which defines helpers for accessing a component's
+ * distributed children as a flattened array or string.
+ */
+
+exports.default = function (base) {
+  return function (_base) {
+    _inherits(DistributedChildren, _base);
+
+    function DistributedChildren() {
+      _classCallCheck(this, DistributedChildren);
+
+      return _possibleConstructorReturn(this, Object.getPrototypeOf(DistributedChildren).apply(this, arguments));
+    }
+
+    _createClass(DistributedChildren, [{
+      key: "distributedChildren",
+
+      /*
+       * Returns an in-order collection of children, expanding any content nodes.
+       * Like the standard children property, this skips text nodes.
+       *
+       * TODO: This walks the whole content tree every time the list is requested.
+       * It'd be nice to cache the answer and invalidate it only when content
+       * actually changes.
+       */
+      get: function get() {
+        return expandContentElements(this.children, false);
+      }
+
+      /*
+       * Returns an in-order collection of child nodes, expanding any content nodes.
+       * Like the standard childNodes property, this includes text nodes.
+       */
+
+    }, {
+      key: "distributedChildNodes",
+      get: function get() {
+        return expandContentElements(this.childNodes, true);
+      }
+
+      /*
+       * Returns the concatenated text content of all child nodes, expanding any
+       * content nodes.
+       */
+
+    }, {
+      key: "distributedTextContent",
+      get: function get() {
+        var strings = this.distributedChildNodes.map(function (child) {
+          return child.textContent;
+        });
+        return strings.join('');
+      }
+    }]);
+
+    return DistributedChildren;
+  }(base);
+};
+
+/*
+ * Given a array of nodes, return a new array with any content elements expanded
+ * to the nodes distributed to that content element. This rule is applied
+ * recursively.
+ *
+ * If includeTextNodes is true, text nodes will be included, as in the
+ * standard childNodes property; by default, this skips text nodes, like the
+ * standard children property.
+ */
+
+function expandContentElements(nodes, includeTextNodes) {
+  var _ref;
+
+  var expanded = Array.prototype.map.call(nodes, function (node) {
+    // We want to see if the node is an instanceof HTMLSlotELement, but
+    // that class won't exist if the browser that doesn't support native
+    // Shadow DOM and if the Shadow DOM polyfill hasn't been loaded. Instead,
+    // we do a simplistic check to see if the tag name is "slot" or "content".
+    if (node.localName && (node.localName === "slot" || node.localName === "content")) {
+      // content element; use its distributed nodes instead.
+      var distributedNodes = node.getDistributedNodes();
+      return distributedNodes ? expandContentElements(distributedNodes, includeTextNodes) : [];
+    } else if (node instanceof HTMLElement) {
+      // Plain element; use as is.
+      return [node];
+    } else if (node instanceof Text && includeTextNodes) {
+      // Text node.
+      return [node];
+    } else {
+      // Comment, processing instruction, etc.; skip.
+      return [];
+    }
+  });
+  var flattened = (_ref = []).concat.apply(_ref, _toConsumableArray(expanded));
+  return flattened;
+}
+
 },{}],4:[function(require,module,exports){
@@ -303,3 +349,72 @@ 'use strict';
 /**
- * @class TemplateStamping
+ * @class ShadowElementReferences
+ * @classdesc Mixin to create references to elements in a component's Shadow
+ * DOM subtree
+ *
+ * This adds a member on the component called `$` that can be used to reference
+ * shadow elements with IDs. E.g., if component's shadow contains an element
+ * `<button id="foo">`, then this mixin will create a member `this.$.foo` that
+ * points to that button. Such references simplify a component's access to its
+ * own elements.
+ *
+ * This trades off a one-time cost of querying all elements in the shadow tree
+ * against having to query for an element each time the component wants to
+ * inspect or manipulate it.
+ *
+ * This mixin is inspired by Polymer's automatic node finding feature.
+ * See https://www.polymer-project.org/1.0/docs/devguide/local-dom.html#node-finding.
+ */
+
+exports.default = function (base) {
+  return function (_base) {
+    _inherits(ShadowElementReferences, _base);
+
+    function ShadowElementReferences() {
+      _classCallCheck(this, ShadowElementReferences);
+
+      return _possibleConstructorReturn(this, Object.getPrototypeOf(ShadowElementReferences).apply(this, arguments));
+    }
+
+    _createClass(ShadowElementReferences, [{
+      key: 'createdCallback',
+      value: function createdCallback() {
+        var _this2 = this;
+
+        if (_get(Object.getPrototypeOf(ShadowElementReferences.prototype), 'createdCallback', this)) {
+          _get(Object.getPrototypeOf(ShadowElementReferences.prototype), 'createdCallback', this).call(this);
+        }
+        if (this.shadowRoot) {
+          this.$ = {};
+          var nodesWithIds = this.shadowRoot.querySelectorAll('[id]');
+          [].forEach.call(nodesWithIds, function (node) {
+            var id = node.getAttribute('id');
+            _this2.$[id] = node;
+          });
+        }
+      }
+    }]);
+
+    return ShadowElementReferences;
+  }(base);
+};
+
+},{}],5:[function(require,module,exports){
+'use strict';
+
+var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+var _get = function get(object, property, receiver) { if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { return get(parent, property, receiver); } } else if ("value" in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } };
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
+
+/**
+ * @class ShadowTemplate
  * @classdesc Mixin for stamping a template into a Shadow DOM subtree upon
@@ -322,11 +437,11 @@ * component instantiation
   return function (_base) {
-    _inherits(TemplateStamping, _base);
+    _inherits(ShadowTemplate, _base);
 
-    function TemplateStamping() {
-      _classCallCheck(this, TemplateStamping);
+    function ShadowTemplate() {
+      _classCallCheck(this, ShadowTemplate);
 
-      return _possibleConstructorReturn(this, Object.getPrototypeOf(TemplateStamping).apply(this, arguments));
+      return _possibleConstructorReturn(this, Object.getPrototypeOf(ShadowTemplate).apply(this, arguments));
     }
 
-    _createClass(TemplateStamping, [{
+    _createClass(ShadowTemplate, [{
       key: 'createdCallback',
@@ -339,4 +454,4 @@
       value: function createdCallback() {
-        if (_get(Object.getPrototypeOf(TemplateStamping.prototype), 'createdCallback', this)) {
-          _get(Object.getPrototypeOf(TemplateStamping.prototype), 'createdCallback', this).call(this);
+        if (_get(Object.getPrototypeOf(ShadowTemplate.prototype), 'createdCallback', this)) {
+          _get(Object.getPrototypeOf(ShadowTemplate.prototype), 'createdCallback', this).call(this);
         }
@@ -370,3 +485,3 @@ var template = this.template;
 
-    return TemplateStamping;
+    return ShadowTemplate;
   }(base);
@@ -404,3 +519,3 @@ };
 
-},{}],5:[function(require,module,exports){
+},{}],6:[function(require,module,exports){
 'use strict';
@@ -420,9 +535,9 @@
 
-var _TemplateStamping = require('../../basic-component-mixins/src/TemplateStamping');
+var _ShadowTemplate = require('../../basic-component-mixins/src/ShadowTemplate');
 
-var _TemplateStamping2 = _interopRequireDefault(_TemplateStamping);
+var _ShadowTemplate2 = _interopRequireDefault(_ShadowTemplate);
 
-var _AutomaticNodeFinding = require('../../basic-component-mixins/src/AutomaticNodeFinding');
+var _ShadowElementReferences = require('../../basic-component-mixins/src/ShadowElementReferences');
 
-var _AutomaticNodeFinding2 = _interopRequireDefault(_AutomaticNodeFinding);
+var _ShadowElementReferences2 = _interopRequireDefault(_ShadowElementReferences);
 
@@ -433,2 +548,6 @@ var _AttributeMarshalling = require('../../basic-component-mixins/src/AttributeMarshalling');
 
+var _DistributedChildren = require('../../basic-component-mixins/src/DistributedChildren');
+
+var _DistributedChildren2 = _interopRequireDefault(_DistributedChildren);
+
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
@@ -444,3 +563,4 @@
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 * that mixes in some common features: template stamping into a shadow root,
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                * automatic node finding, and marshalling between attributes and properties
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                * shadow element references, marshalling attributes to properties, and
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                * retrieving the children distributed to a component.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 *
@@ -480,9 +600,9 @@ * This base class is not special in any way, and is defined only as a
   return ElementBase;
-}((0, _Composable2.default)(HTMLElement).compose(_TemplateStamping2.default, // before node finding, so shadow root is populated
-_AutomaticNodeFinding2.default, // before marshalling, so marshalled properties can use it
-_AttributeMarshalling2.default));
+}((0, _Composable2.default)(HTMLElement).compose(_ShadowTemplate2.default, // before node finding, so shadow root is populated
+_ShadowElementReferences2.default, // before marshalling, so properties can use refs
+_AttributeMarshalling2.default, _DistributedChildren2.default));
 
 exports.default = ElementBase;
 
-},{"../../basic-component-mixins/src/AttributeMarshalling":1,"../../basic-component-mixins/src/AutomaticNodeFinding":2,"../../basic-component-mixins/src/Composable":3,"../../basic-component-mixins/src/TemplateStamping":4}]},{},[5])
-//# sourceMappingURL=data:application/json;charset:utf-8;base64,{"version":3,"sources":["node_modules/browser-pack/_prelude.js","packages/basic-component-mixins/src/AttributeMarshalling.js","packages/basic-component-mixins/src/AutomaticNodeFinding.js","packages/basic-component-mixins/src/Composable.js","packages/basic-component-mixins/src/TemplateStamping.js","packages/basic-element-base/src/ElementBase.js"],"names":[],"mappings":"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","file":"generated.js","sourceRoot":"","sourcesContent":["(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require==\"function\"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error(\"Cannot find module '\"+o+\"'\");throw f.code=\"MODULE_NOT_FOUND\",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require==\"function\"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})","/**\n * @class AttributeMarshalling\n * @classdesc Mixin which marshalls attributes to properties (and eventually\n * vice versa)\n *\n * This only supports string properties for now.\n */\n\n\nexport default (base) => class AttributeMarshalling extends base {\n\n  /*\n   * Handle a change to the attribute with the given name.\n   */\n  attributeChangedCallback(name, oldValue, newValue) {\n    if (super.attributeChangedCallback) { super.attributeChangedCallback(); }\n    // If the attribute name corresponds to a property name, then set that\n    // property. Ignore changes in standard HTMLElement properties.\n    let propertyName = attributeToPropertyName(name);\n    if (propertyName in this && !(propertyName in HTMLElement.prototype)) {\n      this[propertyName] = newValue;\n    }\n  }\n\n  createdCallback() {\n    if (super.createdCallback) { super.createdCallback(); }\n    [].forEach.call(this.attributes, attribute => {\n      this.attributeChangedCallback(attribute.name, undefined, attribute.value);\n    });\n  }\n\n};\n\n\n// Convert camel case fooBar name to hyphenated foo-bar.\nfunction attributeToPropertyName(attributeName) {\n  let propertyName = attributeName.replace(/-([a-z])/g, m => m[1].toUpperCase());\n  return propertyName;\n}\n\n// Convert hyphenated foo-bar name to camel case fooBar.\n// TODO: Use this when we support reflection of properties to attributes.\n// function propertyToAttributeName(propertyName) {\n//   let attributeName = propertyName.replace(/([a-z][A-Z])/g, g => g[0] + '-' + g[1].toLowerCase());\n//   return attributeName;\n// }\n","/**\n * @class AutomaticNodeFinding\n * @classdesc Mixin to create references to elements in a component's Shadow\n * DOM subtree\n *\n * This adds a member on the component called `$` that can be used to reference\n * elements with IDs. E.g., if component's shadow contains an element\n * `<button id=\"foo\">`, then this mixin will create a member `this.$.foo` that\n * points to that button. Such references simplify a component's access to its\n * own elements.\n *\n * This trades off a one-time cost of querying all elements in the shadow tree\n * against having to query for an element each time the component wants to\n * inspect or manipulate it.\n *\n * This mixin is inspired by Polymer's automatic node finding feature.\n * See https://www.polymer-project.org/1.0/docs/devguide/local-dom.html#node-finding.\n */\n\n\nexport default (base) => class AutomaticNodeFinding extends base {\n\n  createdCallback() {\n    if (super.createdCallback) { super.createdCallback(); }\n    if (this.shadowRoot) {\n      this.$ = {};\n      let nodesWithIds = this.shadowRoot.querySelectorAll('[id]');\n      [].forEach.call(nodesWithIds, node => {\n        let id = node.getAttribute('id');\n        this.$[id] = node;\n      });\n    }\n  }\n\n};\n","/**\n * @class Composable\n * @classdesc Mixin to make a class more easily composable with other mixins\n *\n * The main contribution is the introduction of a `compose` method that applies\n * a set of mixin functions and returns the resulting new class. This sugar\n * can make the application of many mixins at once easier to read.\n */\n\n\nexport default (base) => class Composable extends base {\n\n  /**\n   * Apply a set of mixin functions or mixin objects to the present class and\n   * return the new class.\n   *\n   * A call like\n   *\n   *     let MyClass = Mixin1(Mixin2(Mixin3(Mixin4(Mixin5(BaseClass)))));\n   *\n   * Can be converted to:\n   *\n   *     let MyClass = Composable(BaseClass).compose(\n   *       Mixin1,\n   *       Mixin2,\n   *       Mixin3,\n   *       Mixin4,\n   *       Mixin5\n   *     );\n   *\n   * This function can also take mixin objects. A mixin object is just a\n   * shorthand for a mixin function that creates a new subclass with the given\n   * members. The mixin object's members are *not* copied directly onto the\n   * prototype of the base class, as with traditional mixins.\n   */\n  static compose(...mixins) {\n    // We create a new subclass for each mixin in turn. The result becomes\n    // the base class extended by any subsequent mixins. It turns out that\n    // we can use Array.reduce() to concisely express this, using the current\n    // object as the seed for reduce().\n    return mixins.reduce(composeClass, this);\n  }\n\n};\n\n\n// Properties defined by Object that we don't want to mixin.\nconst NON_MIXABLE_OBJECT_PROPERTIES = [\n  'constructor'\n];\n\n/*\n * Apply the mixin to the given base class to return a new class.\n * The mixin can either be a function that returns the modified class, or a\n * plain object whose members will be copied to the new class' prototype.\n */\nfunction composeClass(base, mixin) {\n  if (typeof mixin === 'function') {\n    // Mixin function\n    return mixin(base);\n  } else {\n    // Mixin object\n    class Subclass extends base {}\n    copyOwnProperties(mixin, Subclass.prototype, NON_MIXABLE_OBJECT_PROPERTIES);\n    return Subclass;\n  }\n}\n\n\n/*\n * Copy the given properties/methods to the target.\n * Return the updated target.\n */\nfunction copyOwnProperties(source, target, ignorePropertyNames = []) {\n  Object.getOwnPropertyNames(source).forEach(name => {\n    if (ignorePropertyNames.indexOf(name) < 0) {\n      let descriptor = Object.getOwnPropertyDescriptor(source, name);\n      Object.defineProperty(target, name, descriptor);\n    }\n  });\n  return target;\n}\n","/**\n * @class TemplateStamping\n * @classdesc Mixin for stamping a template into a Shadow DOM subtree upon\n * component instantiation\n *\n * If a component defines a template property (as a string or referencing a HTML\n * template), when the component class is instantiated, a shadow root will be\n * created on the instance, and the contents of the template will be cloned into\n * the shadow root.\n *\n * For the time being, this extension retains support for Shadow DOM v0.\n * That will eventually be deprecated as browsers implement Shadow DOM v1.\n */\n\n\n// Feature detection for old Shadow DOM v0.\nconst USING_SHADOW_DOM_V0 = (typeof HTMLElement.prototype.createShadowRoot !== 'undefined');\n\n\nexport default (base) => class TemplateStamping extends base {\n\n  /*\n   * If the component defines a template, a shadow root will be created on the\n   * component instance, and the template stamped into it.\n   */\n  createdCallback() {\n    if (super.createdCallback) { super.createdCallback(); }\n    let template = this.template;\n    // TODO: Save the processed template with the component's class prototype\n    // so it doesn't need to be processed with every instantiation.\n    if (template) {\n\n      if (typeof template === 'string') {\n        // Upgrade plain string to real template.\n        template = createTemplateWithInnerHTML(template);\n      }\n\n      if (USING_SHADOW_DOM_V0) {\n        polyfillSlotWithContent(template);\n      }\n\n      if (window.ShadowDOMPolyfill) {\n        shimTemplateStyles(template, this.localName);\n      }\n\n      // this.log(\"cloning template into shadow root\");\n      let root = USING_SHADOW_DOM_V0 ?\n        this.createShadowRoot() :             // Shadow DOM v0\n        this.attachShadow({ mode: 'open' });  // Shadow DOM v1\n      let clone = document.importNode(template.content, true);\n      root.appendChild(clone);\n    }\n  }\n\n};\n\n\n// Convert a plain string of HTML into a real template element.\nfunction createTemplateWithInnerHTML(innerHTML) {\n  let template = document.createElement('template');\n  // REVIEW: Is there an easier way to do this?\n  // We'd like to just set innerHTML on the template content, but since it's\n  // a DocumentFragment, that doesn't work.\n  let div = document.createElement('div');\n  div.innerHTML = innerHTML;\n  while (div.childNodes.length > 0) {\n    template.content.appendChild(div.childNodes[0]);\n  }\n  return template;\n}\n\n// Replace occurences of v1 slot elements with v0 content elements.\n// This does not yet map named slots to content select clauses.\nfunction polyfillSlotWithContent(template) {\n  [].forEach.call(template.content.querySelectorAll('slot'), slotElement => {\n    let contentElement = document.createElement('content');\n    slotElement.parentNode.replaceChild(contentElement, slotElement);\n  });\n}\n\n// Invoke basic style shimming with ShadowCSS.\nfunction shimTemplateStyles(template, tag) {\n  window.WebComponents.ShadowCSS.shimStyling(template.content, tag);\n}\n","/**\n * @class ElementBase\n * @classdesc A sample general-purpose base class for defining custom elements\n * that mixes in some common features: template stamping into a shadow root,\n * automatic node finding, and marshalling between attributes and properties\n *\n * This base class is not special in any way, and is defined only as a\n * convenient shorthand for applying the mixins listed above. You can use this\n * class as a base class for your own elements, or easily create your own base\n * class by applying the same set of mixins.\n *\n * The ElementBase base class does not register itself as a custom element with\n * the browser, and hence cannot be independently instantiated.\n */\n\n\nimport Composable from '../../basic-component-mixins/src/Composable';\nimport TemplateStamping from '../../basic-component-mixins/src/TemplateStamping';\nimport AutomaticNodeFinding from '../../basic-component-mixins/src/AutomaticNodeFinding';\nimport AttributeMarshalling from '../../basic-component-mixins/src/AttributeMarshalling';\n\n\nexport default class ElementBase extends Composable(HTMLElement).compose(\n  TemplateStamping,     // before node finding, so shadow root is populated\n  AutomaticNodeFinding, // before marshalling, so marshalled properties can use it\n  AttributeMarshalling\n) {\n\n  /*\n   * Debugging utility: logs a message, prefixed by the component's tag.\n   */\n  log(text) {\n    if (super.log) { super.log(text); }\n    console.log(`${this.localName}: ${text}`);\n  }\n\n}\n"]}
+},{"../../basic-component-mixins/src/AttributeMarshalling":1,"../../basic-component-mixins/src/Composable":2,"../../basic-component-mixins/src/DistributedChildren":3,"../../basic-component-mixins/src/ShadowElementReferences":4,"../../basic-component-mixins/src/ShadowTemplate":5}]},{},[6])
+//# sourceMappingURL=data:application/json;charset:utf-8;base64,{"version":3,"sources":["node_modules/browser-pack/_prelude.js","packages/basic-component-mixins/src/AttributeMarshalling.js","packages/basic-component-mixins/src/Composable.js","packages/basic-component-mixins/src/DistributedChildren.js","packages/basic-component-mixins/src/ShadowElementReferences.js","packages/basic-component-mixins/src/ShadowTemplate.js","packages/basic-element-base/src/ElementBase.js"],"names":[],"mappings":"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","file":"generated.js","sourceRoot":"","sourcesContent":["(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require==\"function\"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error(\"Cannot find module '\"+o+\"'\");throw f.code=\"MODULE_NOT_FOUND\",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require==\"function\"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})","/**\n * @class AttributeMarshalling\n * @classdesc Mixin which marshalls attributes to properties (and eventually\n * vice versa)\n *\n * This only supports string properties for now.\n */\n\n\nexport default (base) => class AttributeMarshalling extends base {\n\n  /*\n   * Handle a change to the attribute with the given name.\n   */\n  attributeChangedCallback(name, oldValue, newValue) {\n    if (super.attributeChangedCallback) { super.attributeChangedCallback(); }\n    // If the attribute name corresponds to a property name, then set that\n    // property. Ignore changes in standard HTMLElement properties.\n    let propertyName = attributeToPropertyName(name);\n    if (propertyName in this && !(propertyName in HTMLElement.prototype)) {\n      this[propertyName] = newValue;\n    }\n  }\n\n  createdCallback() {\n    if (super.createdCallback) { super.createdCallback(); }\n    [].forEach.call(this.attributes, attribute => {\n      this.attributeChangedCallback(attribute.name, undefined, attribute.value);\n    });\n  }\n\n};\n\n\n// Convert camel case fooBar name to hyphenated foo-bar.\nfunction attributeToPropertyName(attributeName) {\n  let propertyName = attributeName.replace(/-([a-z])/g, m => m[1].toUpperCase());\n  return propertyName;\n}\n\n// Convert hyphenated foo-bar name to camel case fooBar.\n// TODO: Use this when we support reflection of properties to attributes.\n// function propertyToAttributeName(propertyName) {\n//   let attributeName = propertyName.replace(/([a-z][A-Z])/g, g => g[0] + '-' + g[1].toLowerCase());\n//   return attributeName;\n// }\n","/**\n * @class Composable\n * @classdesc Mixin to make a class more easily composable with other mixins\n *\n * The main contribution is the introduction of a `compose` method that applies\n * a set of mixin functions and returns the resulting new class. This sugar\n * can make the application of many mixins at once easier to read.\n */\n\n\nexport default (base) => class Composable extends base {\n\n  /**\n   * Apply a set of mixin functions or mixin objects to the present class and\n   * return the new class.\n   *\n   * A call like\n   *\n   *     let MyClass = Mixin1(Mixin2(Mixin3(Mixin4(Mixin5(BaseClass)))));\n   *\n   * Can be converted to:\n   *\n   *     let MyClass = Composable(BaseClass).compose(\n   *       Mixin1,\n   *       Mixin2,\n   *       Mixin3,\n   *       Mixin4,\n   *       Mixin5\n   *     );\n   *\n   * This function can also take mixin objects. A mixin object is just a\n   * shorthand for a mixin function that creates a new subclass with the given\n   * members. The mixin object's members are *not* copied directly onto the\n   * prototype of the base class, as with traditional mixins.\n   */\n  static compose(...mixins) {\n    // We create a new subclass for each mixin in turn. The result becomes\n    // the base class extended by any subsequent mixins. It turns out that\n    // we can use Array.reduce() to concisely express this, using the current\n    // object as the seed for reduce().\n    return mixins.reduce(composeClass, this);\n  }\n\n};\n\n\n// Properties defined by Object that we don't want to mixin.\nconst NON_MIXABLE_OBJECT_PROPERTIES = [\n  'constructor'\n];\n\n/*\n * Apply the mixin to the given base class to return a new class.\n * The mixin can either be a function that returns the modified class, or a\n * plain object whose members will be copied to the new class' prototype.\n */\nfunction composeClass(base, mixin) {\n  if (typeof mixin === 'function') {\n    // Mixin function\n    return mixin(base);\n  } else {\n    // Mixin object\n    class Subclass extends base {}\n    copyOwnProperties(mixin, Subclass.prototype, NON_MIXABLE_OBJECT_PROPERTIES);\n    return Subclass;\n  }\n}\n\n\n/*\n * Copy the given properties/methods to the target.\n * Return the updated target.\n */\nfunction copyOwnProperties(source, target, ignorePropertyNames = []) {\n  Object.getOwnPropertyNames(source).forEach(name => {\n    if (ignorePropertyNames.indexOf(name) < 0) {\n      let descriptor = Object.getOwnPropertyDescriptor(source, name);\n      Object.defineProperty(target, name, descriptor);\n    }\n  });\n  return target;\n}\n","/**\n * @class DistributedChildren\n * @classdesc Mixin which defines helpers for accessing a component's\n * distributed children as a flattened array or string.\n */\n\n\nexport default (base) => class DistributedChildren extends base {\n\n  /*\n   * Returns an in-order collection of children, expanding any content nodes.\n   * Like the standard children property, this skips text nodes.\n   *\n   * TODO: This walks the whole content tree every time the list is requested.\n   * It'd be nice to cache the answer and invalidate it only when content\n   * actually changes.\n   */\n  get distributedChildren() {\n    return expandContentElements(this.children, false);\n  }\n\n  /*\n   * Returns an in-order collection of child nodes, expanding any content nodes.\n   * Like the standard childNodes property, this includes text nodes.\n   */\n  get distributedChildNodes() {\n    return expandContentElements(this.childNodes, true);\n  }\n\n  /*\n   * Returns the concatenated text content of all child nodes, expanding any\n   * content nodes.\n   */\n  get distributedTextContent() {\n    let strings = this.distributedChildNodes.map(function(child) {\n      return child.textContent;\n    });\n    return strings.join('');\n  }\n\n};\n\n\n/*\n * Given a array of nodes, return a new array with any content elements expanded\n * to the nodes distributed to that content element. This rule is applied\n * recursively.\n *\n * If includeTextNodes is true, text nodes will be included, as in the\n * standard childNodes property; by default, this skips text nodes, like the\n * standard children property.\n */\nfunction expandContentElements(nodes, includeTextNodes) {\n  let expanded = Array.prototype.map.call(nodes, node => {\n    // We want to see if the node is an instanceof HTMLSlotELement, but\n    // that class won't exist if the browser that doesn't support native\n    // Shadow DOM and if the Shadow DOM polyfill hasn't been loaded. Instead,\n    // we do a simplistic check to see if the tag name is \"slot\" or \"content\".\n    if (node.localName && (node.localName === \"slot\" || node.localName === \"content\")) {\n      // content element; use its distributed nodes instead.\n      let distributedNodes = node.getDistributedNodes();\n      return distributedNodes ?\n        expandContentElements(distributedNodes, includeTextNodes) :\n        [];\n    } else if (node instanceof HTMLElement) {\n      // Plain element; use as is.\n      return [node];\n    } else if (node instanceof Text && includeTextNodes) {\n      // Text node.\n      return [node];\n    } else {\n      // Comment, processing instruction, etc.; skip.\n      return [];\n    }\n  });\n  let flattened = [].concat(...expanded);\n  return flattened;\n}\n","/**\n * @class ShadowElementReferences\n * @classdesc Mixin to create references to elements in a component's Shadow\n * DOM subtree\n *\n * This adds a member on the component called `$` that can be used to reference\n * shadow elements with IDs. E.g., if component's shadow contains an element\n * `<button id=\"foo\">`, then this mixin will create a member `this.$.foo` that\n * points to that button. Such references simplify a component's access to its\n * own elements.\n *\n * This trades off a one-time cost of querying all elements in the shadow tree\n * against having to query for an element each time the component wants to\n * inspect or manipulate it.\n *\n * This mixin is inspired by Polymer's automatic node finding feature.\n * See https://www.polymer-project.org/1.0/docs/devguide/local-dom.html#node-finding.\n */\n\n\nexport default (base) => class ShadowElementReferences extends base {\n\n  createdCallback() {\n    if (super.createdCallback) { super.createdCallback(); }\n    if (this.shadowRoot) {\n      this.$ = {};\n      let nodesWithIds = this.shadowRoot.querySelectorAll('[id]');\n      [].forEach.call(nodesWithIds, node => {\n        let id = node.getAttribute('id');\n        this.$[id] = node;\n      });\n    }\n  }\n\n};\n","/**\n * @class ShadowTemplate\n * @classdesc Mixin for stamping a template into a Shadow DOM subtree upon\n * component instantiation\n *\n * If a component defines a template property (as a string or referencing a HTML\n * template), when the component class is instantiated, a shadow root will be\n * created on the instance, and the contents of the template will be cloned into\n * the shadow root.\n *\n * For the time being, this extension retains support for Shadow DOM v0.\n * That will eventually be deprecated as browsers implement Shadow DOM v1.\n */\n\n\n// Feature detection for old Shadow DOM v0.\nconst USING_SHADOW_DOM_V0 = (typeof HTMLElement.prototype.createShadowRoot !== 'undefined');\n\n\nexport default (base) => class ShadowTemplate extends base {\n\n  /*\n   * If the component defines a template, a shadow root will be created on the\n   * component instance, and the template stamped into it.\n   */\n  createdCallback() {\n    if (super.createdCallback) { super.createdCallback(); }\n    let template = this.template;\n    // TODO: Save the processed template with the component's class prototype\n    // so it doesn't need to be processed with every instantiation.\n    if (template) {\n\n      if (typeof template === 'string') {\n        // Upgrade plain string to real template.\n        template = createTemplateWithInnerHTML(template);\n      }\n\n      if (USING_SHADOW_DOM_V0) {\n        polyfillSlotWithContent(template);\n      }\n\n      if (window.ShadowDOMPolyfill) {\n        shimTemplateStyles(template, this.localName);\n      }\n\n      // this.log(\"cloning template into shadow root\");\n      let root = USING_SHADOW_DOM_V0 ?\n        this.createShadowRoot() :             // Shadow DOM v0\n        this.attachShadow({ mode: 'open' });  // Shadow DOM v1\n      let clone = document.importNode(template.content, true);\n      root.appendChild(clone);\n    }\n  }\n\n};\n\n\n// Convert a plain string of HTML into a real template element.\nfunction createTemplateWithInnerHTML(innerHTML) {\n  let template = document.createElement('template');\n  // REVIEW: Is there an easier way to do this?\n  // We'd like to just set innerHTML on the template content, but since it's\n  // a DocumentFragment, that doesn't work.\n  let div = document.createElement('div');\n  div.innerHTML = innerHTML;\n  while (div.childNodes.length > 0) {\n    template.content.appendChild(div.childNodes[0]);\n  }\n  return template;\n}\n\n// Replace occurences of v1 slot elements with v0 content elements.\n// This does not yet map named slots to content select clauses.\nfunction polyfillSlotWithContent(template) {\n  [].forEach.call(template.content.querySelectorAll('slot'), slotElement => {\n    let contentElement = document.createElement('content');\n    slotElement.parentNode.replaceChild(contentElement, slotElement);\n  });\n}\n\n// Invoke basic style shimming with ShadowCSS.\nfunction shimTemplateStyles(template, tag) {\n  window.WebComponents.ShadowCSS.shimStyling(template.content, tag);\n}\n","/**\n * @class ElementBase\n * @classdesc A sample general-purpose base class for defining custom elements\n * that mixes in some common features: template stamping into a shadow root,\n * shadow element references, marshalling attributes to properties, and\n * retrieving the children distributed to a component.\n *\n * This base class is not special in any way, and is defined only as a\n * convenient shorthand for applying the mixins listed above. You can use this\n * class as a base class for your own elements, or easily create your own base\n * class by applying the same set of mixins.\n *\n * The ElementBase base class does not register itself as a custom element with\n * the browser, and hence cannot be independently instantiated.\n */\n\n\nimport Composable from '../../basic-component-mixins/src/Composable';\nimport ShadowTemplate from '../../basic-component-mixins/src/ShadowTemplate';\nimport ShadowElementReferences from '../../basic-component-mixins/src/ShadowElementReferences';\nimport AttributeMarshalling from '../../basic-component-mixins/src/AttributeMarshalling';\nimport DistributedChildren from '../../basic-component-mixins/src/DistributedChildren';\n\n\nexport default class ElementBase extends Composable(HTMLElement).compose(\n  ShadowTemplate,          // before node finding, so shadow root is populated\n  ShadowElementReferences, // before marshalling, so properties can use refs\n  AttributeMarshalling,\n  DistributedChildren\n) {\n\n  /*\n   * Debugging utility: logs a message, prefixed by the component's tag.\n   */\n  log(text) {\n    if (super.log) { super.log(text); }\n    console.log(`${this.localName}: ${text}`);\n  }\n\n}\n"]}

package.json

 {
   "name": "basic-element-base",
-  "version": "0.0.3",
+  "version": "0.7.0",
   "description": "A sample general-purpose base class for defining custom elements that mixes in some common features: template stamping into a shadow root, automatic node finding, and marshalling between attributes and properties.",
@@ -15,7 +15,9 @@ "homepage": "https://component.kitchen",
   "dependencies": {
-    "basic-component-mixins": "^0.0.3"
+    "basic-component-mixins": "^0.7.0"
   },
   "browserify": {
-    "transform": ["babelify"]
+    "transform": [
+      "babelify"
+    ]
   }
-}
+}

README.md

@@ -5,3 +5,4 @@ <a name="ElementBase"></a>
 that mixes in some common features: template stamping into a shadow root,
-automatic node finding, and marshalling between attributes and properties
+shadow element references, marshalling attributes to properties, and
+retrieving the children distributed to a component.
 
@@ -8,0 +9,0 @@ This base class is not special in any way, and is defined only as a

src/ElementBase.js

@@ -5,3 +5,4 @@ /**
  * that mixes in some common features: template stamping into a shadow root,
- * automatic node finding, and marshalling between attributes and properties
+ * shadow element references, marshalling attributes to properties, and
+ * retrieving the children distributed to a component.
  *
@@ -19,11 +20,13 @@ * This base class is not special in any way, and is defined only as a
 import Composable from '../../basic-component-mixins/src/Composable';
-import TemplateStamping from '../../basic-component-mixins/src/TemplateStamping';
-import AutomaticNodeFinding from '../../basic-component-mixins/src/AutomaticNodeFinding';
+import ShadowTemplate from '../../basic-component-mixins/src/ShadowTemplate';
+import ShadowElementReferences from '../../basic-component-mixins/src/ShadowElementReferences';
 import AttributeMarshalling from '../../basic-component-mixins/src/AttributeMarshalling';
+import DistributedChildren from '../../basic-component-mixins/src/DistributedChildren';
 
 
 export default class ElementBase extends Composable(HTMLElement).compose(
-  TemplateStamping,     // before node finding, so shadow root is populated
-  AutomaticNodeFinding, // before marshalling, so marshalled properties can use it
-  AttributeMarshalling
+  ShadowTemplate,          // before node finding, so shadow root is populated
+  ShadowElementReferences, // before marshalling, so properties can use refs
+  AttributeMarshalling,
+  DistributedChildren
 ) {
@@ -30,0 +33,0 @@

New alerts

New author

Supply chain risk

A new npm collaborator published a version of the package for the first time. New collaborators are usually benign additions to a project, but do indicate a change to the security surface area of a package.

Found 1 instance in 1 package

Improved metrics

Total package byte prevSize

66230

increased by21.18%

Lines of code

643

increased by23.89%

Number of lines in readme file

17

increased by6.25%

Worsened metrics

Number of medium supply chain risk alerts

1

increased byInfinity%

Dependency changes

• + Addedbasic-component-mixins@0.7.6(transitive)

• - Removedbasic-component-mixins@0.0.3(transitive)

• Updatedbasic-component-mixins@^0.7.0