brew-js-react 0.2.10 → 0.3.0

package/mixin.js

@@ -5,7 +5,6 @@ import AnimateMixin from "./mixins/AnimateMixin.js";
 import AnimateSequenceItemMixin from "./mixins/AnimateSequenceItemMixin.js";
 import AnimateSequenceMixin from "./mixins/AnimateSequenceMixin.js";
 import ClassNameMixin from "./mixins/ClassNameMixin.js";
-import ErrorHandlerMixin from "./mixins/ErrorHandlerMixin.js";
 import FlyoutMixin from "./mixins/FlyoutMixin.js";
 import FlyoutToggleMixin from "./mixins/FlyoutToggleMixin.js";
 import FocusStateMixin from "./mixins/FocusStateMixin.js";
@@ -27,7 +26,6 @@ function createUseFunction(ctor) {
 
 export const useAnimateMixin = createUseFunction(AnimateMixin);
 export const useAnimateSequenceMixin = createUseFunction(AnimateSequenceMixin);
-export const useErrorHandlerMixin = createUseFunction(ErrorHandlerMixin);
 export const useFlyoutMixin = createUseFunction(FlyoutMixin);
 export const useFocusStateMixin = createUseFunction(FocusStateMixin);
 export const useLoadingStateMixin = createUseFunction(LoadingStateMixin);
@@ -53,7 +51,6 @@ export {
     AnimateSequenceItemMixin,
     AnimateSequenceMixin,
     ClassNameMixin,
-    ErrorHandlerMixin,
     FlyoutMixin,
     FlyoutToggleMixin,
     FocusStateMixin,

package/mixins/ClassNameMixin.js

@@ -1,57 +1,56 @@
-import { definePrototype, each, equal, extend, setImmediate } from "../include/zeta-dom/util.js";
-import { containsOrEquals } from "../include/zeta-dom/domUtil.js";
-import dom from "../include/zeta-dom/dom.js";
-import StatefulMixin from "./StatefulMixin.js";
-
-const ClassNameMixinSuper = StatefulMixin.prototype;
-
-function checkState(self, element, state, isAsync) {
-    var classNames = state.classNames;
-    var prev = extend({}, classNames);
-    each(self.classNames, function (i, v) {
-        classNames[v] = element.classList.contains(v);
-    });
-    if (!equal(prev, classNames)) {
-        var cb = self.onClassNameUpdated.bind(self, element, prev, extend({}, classNames));
-        if (isAsync) {
-            setImmediate(cb);
-        } else {
-            cb();
-        }
-    }
-}
-
-export default function ClassNameMixin(classNames) {
-    StatefulMixin.call(this);
-    this.classNames = classNames || [];
-}
-
-definePrototype(ClassNameMixin, StatefulMixin, {
-    getClassNames: function () {
-        return [this.state.classNames];
-    },
-    getRef: function () {
-        var self = this;
-        var element = self.state.element;
-        if (element && containsOrEquals(dom.root, element)) {
-            checkState(self, element, self.state, true);
-        }
-        return ClassNameMixinSuper.getRef.call(this);
-    },
-    initState: function () {
-        return {
-            element: null,
-            classNames: {}
-        };
-    },
-    initElement: function (element, state) {
-        var self = this;
-        dom.watchAttributes(element, ['class'], function (nodes) {
-            if (nodes.includes(element)) {
-                checkState(self, element, state);
-            }
-        });
-    },
-    onClassNameUpdated: function (element, prevState, state) {
-    }
-});
+import { definePrototype, each, equal, extend, setImmediate } from "../include/zeta-dom/util.js";
+import { containsOrEquals } from "../include/zeta-dom/domUtil.js";
+import dom from "../include/zeta-dom/dom.js";
+import { watchOwnAttributes } from "../include/zeta-dom/observe.js";
+import StatefulMixin from "./StatefulMixin.js";
+
+const ClassNameMixinSuper = StatefulMixin.prototype;
+
+function checkState(self, element, state, isAsync) {
+    var classNames = state.classNames;
+    var prev = extend({}, classNames);
+    each(self.classNames, function (i, v) {
+        classNames[v] = element.classList.contains(v);
+    });
+    if (!equal(prev, classNames)) {
+        var cb = self.onClassNameUpdated.bind(self, element, prev, extend({}, classNames));
+        if (isAsync) {
+            setImmediate(cb);
+        } else {
+            cb();
+        }
+    }
+}
+
+export default function ClassNameMixin(classNames) {
+    StatefulMixin.call(this);
+    this.classNames = classNames || [];
+}
+
+definePrototype(ClassNameMixin, StatefulMixin, {
+    getClassNames: function () {
+        return [this.state.classNames];
+    },
+    getRef: function () {
+        var self = this;
+        var element = self.state.element;
+        if (element && containsOrEquals(dom.root, element)) {
+            checkState(self, element, self.state, true);
+        }
+        return ClassNameMixinSuper.getRef.call(this);
+    },
+    initState: function () {
+        return {
+            element: null,
+            classNames: {}
+        };
+    },
+    initElement: function (element, state) {
+        var self = this;
+        watchOwnAttributes(element, 'class', function () {
+            checkState(self, element, state);
+        });
+    },
+    onClassNameUpdated: function (element, prevState, state) {
+    }
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "brew-js-react",
-  "version": "0.2.10",
+  "version": "0.3.0",
   "description": "",
   "type": "module",
   "main": "index.js",
@@ -20,7 +20,7 @@
   "dependencies": {
     "brew-js": ">=0.4.5",
     "waterpipe": "^2.5.0",
-    "zeta-dom": ">=0.2.11",
+    "zeta-dom": ">=0.3.1",
     "zeta-dom-react": ">=0.2.1"
   },
   "peerDependencies": {

package/mixins/ErrorHandlerMixin.d.ts

@@ -1,37 +0,0 @@
-import dom from "../include/zeta-dom/dom";
-import StatefulMixin from "./StatefulMixin";
-
-/**
- * @deprecated
- */
-export default class ErrorHandlerMixin extends StatefulMixin {
-    /**
-     * Catches errors from promises registered to descandant elements by {@link dom.lock}.
-     * Unfiltered handlers are called after filtered handlers, registered by other overloads, regardless of order.
-     *
-     * If handler returns a value other than `undefined`, including promises resolving to whatever values,
-     * the error is marked as handled and no further handlers are called nor will be propagated up the DOM tree.
-     * @param handler Callback to be invoked.
-     */
-    catch(handler: (e: any) => any): Zeta.UnregisterCallback;
-
-    /**
-     * Catches errors with property `code` matching the specified code, from promises registered to descandant elements by {@link dom.lock}.
-     *
-     * If handler returns a value other than `undefined`, including promises resolving to whatever values,
-     * the error is marked as handled and no further handlers are called nor will be propagated up the DOM tree.
-     * @param code Value to be matched against.
-     * @param handler Callback to be invoked when the criteria matches.
-     */
-    catch(code: string, handler: (e: Error) => any): Zeta.UnregisterCallback;
-
-    /**
-     * Catches errors that are instances of the specified error type, from promises registered to descandant elements by {@link dom.lock}.
-     *
-     * If handler returns a value other than `undefined`, including promises resolving to whatever values,
-     * the error is marked as handled and no further handlers are called nor will be propagated up the DOM tree.
-     * @param type Constructor of a specific error type.
-     * @param handler Callback to be invoked when the criteria matches.
-     */
-    catch<T extends Error>(type: typeof T, handler: (e: T) => any): Zeta.UnregisterCallback;
-}

package/mixins/ErrorHandlerMixin.js

@@ -1,40 +0,0 @@
-import dom from "../include/zeta-dom/dom.js";
-import { ZetaEventContainer } from "../include/zeta-dom/events.js";
-import { definePrototype, is, isFunction } from "../include/zeta-dom/util.js";
-import StatefulMixin from "./StatefulMixin.js";
-
-const ErrorHandlerMixinSuper = StatefulMixin.prototype;
-const emitter = new ZetaEventContainer();
-
-function isErrorMatched(filter, error) {
-    if (isFunction(filter)) {
-        return is(error, filter);
-    }
-    return error && error.code === filter;
-}
-
-export default function ErrorHandlerMixin() {
-    StatefulMixin.call(this);
-}
-
-definePrototype(ErrorHandlerMixin, StatefulMixin, {
-    catch: function (filter, callback) {
-        if (!callback) {
-            callback = filter;
-            filter = null;
-        }
-        return emitter.add(this, filter ? 'error' : 'default', function (e) {
-            if (!filter || isErrorMatched(filter, e.error)) {
-                return callback(e.error);
-            }
-        });
-    },
-    initElement: function (element, state) {
-        var self = this;
-        ErrorHandlerMixinSuper.initElement.call(self, element, state);
-        dom.on(element, 'error', function (e) {
-            var data = { error: e.error };
-            return emitter.emit('error', self, data) || emitter.emit('default', self, data);
-        });
-    }
-});