custom-elements-ts 0.0.17 → 0.2.0

package/esm2015/custom-elements-ts.js

@@ -1,283 +0,0 @@
-const toKebabCase = (str) => {
-    return str
-        .replace(/([a-z])([A-Z])/g, '$1-$2')
-        .replace(/[\s_]+/g, '-')
-        .toLowerCase();
-};
-const toCamelCase = (str) => {
-    return str.toLowerCase().replace(/(-\w)/g, (m) => m[1].toUpperCase());
-};
-const toDotCase = (str) => {
-    return str
-        .replace(/(?!^)([A-Z])/g, ' $1')
-        .replace(/[_\s]+(?=[a-zA-Z])/g, '.')
-        .toLowerCase();
-};
-const tryParseInt = (value) => {
-    if (typeof value === 'number' && Number.isInteger(value)) {
-        return value;
-    }
-    if (typeof value === 'string') {
-        const trimmed = value.trim();
-        if (trimmed !== '') {
-            const parsed = Number(trimmed);
-            if (Number.isInteger(parsed) && String(parsed) === trimmed) {
-                return parsed;
-            }
-        }
-    }
-    return value;
-};
-
-const Listen = (eventName, selector) => {
-    return (target, methodName) => {
-        if (!target.constructor.listeners) {
-            target.constructor.listeners = [];
-        }
-        target.constructor.listeners.push({
-            selector: selector,
-            eventName: eventName,
-            handler: target[methodName],
-        });
-    };
-};
-const addEventListeners = (target) => {
-    if (target.constructor.listeners) {
-        const targetRoot = target.shadowRoot || target;
-        for (const listener of target.constructor.listeners) {
-            let eventTarget = target;
-            if (listener.selector) {
-                eventTarget = targetRoot.querySelector(listener.selector);
-            }
-            if (eventTarget) {
-                eventTarget.addEventListener(listener.eventName, (e) => {
-                    listener.handler.call(target, e);
-                });
-            }
-        }
-    }
-};
-const Dispatch = (eventName) => {
-    return (target, propertyName) => {
-        function get() {
-            const self = this;
-            return {
-                emit(options) {
-                    const evtName = eventName ? eventName : toDotCase(propertyName);
-                    self.dispatchEvent(new CustomEvent(evtName, options));
-                },
-            };
-        }
-        Object.defineProperty(target, propertyName, { get });
-    };
-};
-
-const Prop = () => {
-    return (target, propName) => {
-        const attrName = toKebabCase(propName);
-        function get() {
-            const hasOwn = Object.prototype.hasOwnProperty.call(this.props, propName);
-            if (hasOwn) {
-                return this.props[propName];
-            }
-            return this.getAttribute(attrName);
-        }
-        function set(value) {
-            if (this.__connected) {
-                const oldValue = this.props[propName];
-                this.props[propName] = tryParseInt(value);
-                const valueType = typeof value;
-                const shouldReflect = valueType === 'string' || valueType === 'number' || valueType === 'boolean';
-                if (shouldReflect) {
-                    this.setAttribute(attrName, value);
-                }
-                else {
-                    this.onAttributeChange(attrName, oldValue, value, false);
-                }
-            }
-            else {
-                if (!this.hasAttribute(toKebabCase(propName))) {
-                    this.constructor.propsInit[propName] = value;
-                }
-            }
-        }
-        if (!target.constructor.propsInit) {
-            target.constructor.propsInit = {};
-        }
-        target.constructor.propsInit[propName] = null;
-        Object.defineProperty(target, propName, { get, set });
-    };
-};
-const getProps = (target) => {
-    const watchAttributes = target.constructor.watchAttributes;
-    const plainAttributes = Object.assign({}, watchAttributes);
-    Object.keys(plainAttributes).forEach((v) => (plainAttributes[v] = ''));
-    const cycleProps = Object.assign(Object.assign({}, plainAttributes), target.constructor.propsInit);
-    return Object.keys(cycleProps);
-};
-const initializeProps = (target) => {
-    const watchAttributes = target.constructor.watchAttributes;
-    for (const prop of getProps(target)) {
-        if (watchAttributes) {
-            if (watchAttributes[toKebabCase(prop)] === null ||
-                watchAttributes[toKebabCase(prop)] === undefined) {
-                watchAttributes[toKebabCase(prop)] = '';
-            }
-            else {
-                const hasOwn = Object.prototype.hasOwnProperty.call(target.props, prop);
-                const attribValue = hasOwn ? target.props[prop] : target.getAttribute(toKebabCase(prop));
-                if (typeof target[watchAttributes[prop]] === 'function') {
-                    target[watchAttributes[prop]]({ new: attribValue });
-                }
-            }
-        }
-        if (target.constructor.propsInit[prop]) {
-            if (!target.hasAttribute(toKebabCase(prop))) {
-                target[prop] = target.constructor.propsInit[prop];
-            }
-        }
-    }
-};
-
-const CustomElement = (args) => {
-    return (target) => {
-        const tag = args.tag || toKebabCase(target.prototype.constructor.name);
-        const customElement = class extends target {
-            static get observedAttributes() {
-                return Object.keys(this.propsInit || {}).map((x) => toKebabCase(x));
-            }
-            constructor() {
-                super();
-                this.__connected = false;
-                this.props = {};
-                this.showShadowRoot =
-                    args.shadow === undefined || args.shadow === null ? true : args.shadow;
-                if (!this.shadowRoot && this.showShadowRoot) {
-                    this.attachShadow({ mode: 'open' });
-                }
-            }
-            attributeChangedCallback(name, oldValue, newValue) {
-                this.onAttributeChange(name, oldValue, newValue);
-            }
-            onAttributeChange(name, oldValue, newValue, set = true) {
-                if (oldValue !== newValue) {
-                    if (set) {
-                        const propName = toCamelCase(name);
-                        this[propName] = newValue;
-                    }
-                    const watchAttributes = this.constructor.watchAttributes;
-                    if (watchAttributes && watchAttributes[name]) {
-                        const methodToCall = watchAttributes[name];
-                        if (this.__connected) {
-                            if (typeof this[methodToCall] === 'function') {
-                                this[methodToCall]({ old: oldValue, new: newValue });
-                            }
-                        }
-                    }
-                }
-            }
-            connectedCallback() {
-                this.__render();
-                const parentProto = Object.getPrototypeOf(Object.getPrototypeOf(this)) || null;
-                if (parentProto && typeof parentProto.connectedCallback === 'function') {
-                    parentProto.connectedCallback.call(this);
-                }
-                this.__connected = true;
-                addEventListeners(this);
-                initializeProps(this);
-            }
-            __render() {
-                if (this.__connected)
-                    return;
-                const template = document.createElement('template');
-                const style = `${args.style ? `<style>${args.style}</style>` : ''}`;
-                template.innerHTML = `${style}${args.template ? args.template : ''}`;
-                (this.showShadowRoot ? this.shadowRoot : this).appendChild(document.importNode(template.content, true));
-            }
-        };
-        if (!customElements.get(tag)) {
-            customElements.define(tag, customElement);
-        }
-        return customElement;
-    };
-};
-
-const Watch = (attrName) => {
-    return (target, propertyName) => {
-        if (!target.constructor.watchAttributes) {
-            target.constructor.watchAttributes = {};
-        }
-        target.constructor.watchAttributes[toKebabCase(attrName)] = propertyName;
-        if (!target.constructor.propsInit) {
-            target.constructor.propsInit = {};
-        }
-        target.constructor.propsInit[attrName] = null;
-    };
-};
-
-const Toggle = () => {
-    return (target, propName) => {
-        function get() {
-            const getAttribute = (attrName) => {
-                if (this.hasAttribute(attrName)) {
-                    const attrValue = this.getAttribute(attrName);
-                    if (/^(true|false|^$)$/.test(attrValue)) {
-                        return attrValue === 'true' || attrValue === '';
-                    }
-                    else {
-                        return false;
-                    }
-                }
-                return false;
-            };
-            return getAttribute(propName);
-        }
-        function set(value) {
-            const oldValue = value;
-            if (value !== null && value !== undefined) {
-                switch (typeof value) {
-                    case 'boolean':
-                        break;
-                    case 'string':
-                        if (/^(true|false|^$)$/.test(value)) {
-                            value = oldValue === 'true' || oldValue === '';
-                        }
-                        else {
-                            console.warn(`TypeError: Cannot set boolean toggle property '${propName}' to '${value}'`);
-                            value = false;
-                        }
-                        break;
-                    default:
-                        throw new TypeError(`Cannot set boolean toggle property '${propName}' to '${value}'`);
-                }
-            }
-            if (this.__connected) {
-                this.props[propName] = value || false;
-                if (oldValue !== '' && oldValue !== null) {
-                    this.setAttribute(propName, value);
-                }
-                else {
-                    if (value) {
-                        this.setAttribute(propName, '');
-                    }
-                    else {
-                        this.removeAttribute(propName);
-                    }
-                }
-            }
-            else {
-                if (!this.hasAttribute(toKebabCase(propName))) {
-                    this.constructor.propsInit[propName] = value;
-                }
-            }
-        }
-        if (!target.constructor.propsInit) {
-            target.constructor.propsInit = {};
-        }
-        target.constructor.propsInit[propName] = null;
-        Object.defineProperty(target, propName, { get, set });
-    };
-};
-
-export { CustomElement, Dispatch, Listen, Prop, Toggle, Watch, addEventListeners, initializeProps };
-//# sourceMappingURL=custom-elements-ts.js.map

package/esm2015/custom-elements-ts.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"custom-elements-ts.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/esm5/custom-element.d.ts

@@ -1,12 +0,0 @@
-export interface CustomElementMetadata {
-    tag?: string;
-    template?: string;
-    templateUrl?: string;
-    styleUrl?: string;
-    style?: string;
-    shadow?: boolean;
-}
-export interface KeyValue {
-    [key: string]: any;
-}
-export declare const CustomElement: (args: CustomElementMetadata) => (target: any) => any;

package/esm5/custom-elements-ts.js

@@ -1,344 +0,0 @@
-/******************************************************************************
-Copyright (c) Microsoft Corporation.
-
-Permission to use, copy, modify, and/or distribute this software for any
-purpose with or without fee is hereby granted.
-
-THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-PERFORMANCE OF THIS SOFTWARE.
-***************************************************************************** */
-/* global Reflect, Promise, SuppressedError, Symbol, Iterator */
-
-var extendStatics = function(d, b) {
-    extendStatics = Object.setPrototypeOf ||
-        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-        function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
-    return extendStatics(d, b);
-};
-
-function __extends(d, b) {
-    if (typeof b !== "function" && b !== null)
-        throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
-    extendStatics(d, b);
-    function __() { this.constructor = d; }
-    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-}
-
-var __assign = function() {
-    __assign = Object.assign || function __assign(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
-
-typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
-    var e = new Error(message);
-    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
-};
-
-var toKebabCase = function (str) {
-    return str
-        .replace(/([a-z])([A-Z])/g, '$1-$2')
-        .replace(/[\s_]+/g, '-')
-        .toLowerCase();
-};
-var toCamelCase = function (str) {
-    return str.toLowerCase().replace(/(-\w)/g, function (m) { return m[1].toUpperCase(); });
-};
-var toDotCase = function (str) {
-    return str
-        .replace(/(?!^)([A-Z])/g, ' $1')
-        .replace(/[_\s]+(?=[a-zA-Z])/g, '.')
-        .toLowerCase();
-};
-var tryParseInt = function (value) {
-    if (typeof value === 'number' && Number.isInteger(value)) {
-        return value;
-    }
-    if (typeof value === 'string') {
-        var trimmed = value.trim();
-        if (trimmed !== '') {
-            var parsed = Number(trimmed);
-            if (Number.isInteger(parsed) && String(parsed) === trimmed) {
-                return parsed;
-            }
-        }
-    }
-    return value;
-};
-
-var Listen = function (eventName, selector) {
-    return function (target, methodName) {
-        if (!target.constructor.listeners) {
-            target.constructor.listeners = [];
-        }
-        target.constructor.listeners.push({
-            selector: selector,
-            eventName: eventName,
-            handler: target[methodName],
-        });
-    };
-};
-var addEventListeners = function (target) {
-    if (target.constructor.listeners) {
-        var targetRoot = target.shadowRoot || target;
-        var _loop_1 = function (listener) {
-            var eventTarget = target;
-            if (listener.selector) {
-                eventTarget = targetRoot.querySelector(listener.selector);
-            }
-            if (eventTarget) {
-                eventTarget.addEventListener(listener.eventName, function (e) {
-                    listener.handler.call(target, e);
-                });
-            }
-        };
-        for (var _i = 0, _a = target.constructor.listeners; _i < _a.length; _i++) {
-            var listener = _a[_i];
-            _loop_1(listener);
-        }
-    }
-};
-var Dispatch = function (eventName) {
-    return function (target, propertyName) {
-        function get() {
-            var self = this;
-            return {
-                emit: function (options) {
-                    var evtName = eventName ? eventName : toDotCase(propertyName);
-                    self.dispatchEvent(new CustomEvent(evtName, options));
-                },
-            };
-        }
-        Object.defineProperty(target, propertyName, { get: get });
-    };
-};
-
-var Prop = function () {
-    return function (target, propName) {
-        var attrName = toKebabCase(propName);
-        function get() {
-            var hasOwn = Object.prototype.hasOwnProperty.call(this.props, propName);
-            if (hasOwn) {
-                return this.props[propName];
-            }
-            return this.getAttribute(attrName);
-        }
-        function set(value) {
-            if (this.__connected) {
-                var oldValue = this.props[propName];
-                this.props[propName] = tryParseInt(value);
-                var valueType = typeof value;
-                var shouldReflect = valueType === 'string' || valueType === 'number' || valueType === 'boolean';
-                if (shouldReflect) {
-                    this.setAttribute(attrName, value);
-                }
-                else {
-                    this.onAttributeChange(attrName, oldValue, value, false);
-                }
-            }
-            else {
-                if (!this.hasAttribute(toKebabCase(propName))) {
-                    this.constructor.propsInit[propName] = value;
-                }
-            }
-        }
-        if (!target.constructor.propsInit) {
-            target.constructor.propsInit = {};
-        }
-        target.constructor.propsInit[propName] = null;
-        Object.defineProperty(target, propName, { get: get, set: set });
-    };
-};
-var getProps = function (target) {
-    var watchAttributes = target.constructor.watchAttributes;
-    var plainAttributes = __assign({}, watchAttributes);
-    Object.keys(plainAttributes).forEach(function (v) { return (plainAttributes[v] = ''); });
-    var cycleProps = __assign(__assign({}, plainAttributes), target.constructor.propsInit);
-    return Object.keys(cycleProps);
-};
-var initializeProps = function (target) {
-    var watchAttributes = target.constructor.watchAttributes;
-    for (var _i = 0, _a = getProps(target); _i < _a.length; _i++) {
-        var prop = _a[_i];
-        if (watchAttributes) {
-            if (watchAttributes[toKebabCase(prop)] === null ||
-                watchAttributes[toKebabCase(prop)] === undefined) {
-                watchAttributes[toKebabCase(prop)] = '';
-            }
-            else {
-                var hasOwn = Object.prototype.hasOwnProperty.call(target.props, prop);
-                var attribValue = hasOwn ? target.props[prop] : target.getAttribute(toKebabCase(prop));
-                if (typeof target[watchAttributes[prop]] === 'function') {
-                    target[watchAttributes[prop]]({ new: attribValue });
-                }
-            }
-        }
-        if (target.constructor.propsInit[prop]) {
-            if (!target.hasAttribute(toKebabCase(prop))) {
-                target[prop] = target.constructor.propsInit[prop];
-            }
-        }
-    }
-};
-
-var CustomElement = function (args) {
-    return function (target) {
-        var tag = args.tag || toKebabCase(target.prototype.constructor.name);
-        var customElement = (function (_super) {
-            __extends(class_1, _super);
-            function class_1() {
-                var _this = _super.call(this) || this;
-                _this.__connected = false;
-                _this.props = {};
-                _this.showShadowRoot =
-                    args.shadow === undefined || args.shadow === null ? true : args.shadow;
-                if (!_this.shadowRoot && _this.showShadowRoot) {
-                    _this.attachShadow({ mode: 'open' });
-                }
-                return _this;
-            }
-            Object.defineProperty(class_1, "observedAttributes", {
-                get: function () {
-                    return Object.keys(this.propsInit || {}).map(function (x) { return toKebabCase(x); });
-                },
-                enumerable: false,
-                configurable: true
-            });
-            class_1.prototype.attributeChangedCallback = function (name, oldValue, newValue) {
-                this.onAttributeChange(name, oldValue, newValue);
-            };
-            class_1.prototype.onAttributeChange = function (name, oldValue, newValue, set) {
-                if (set === void 0) { set = true; }
-                if (oldValue !== newValue) {
-                    if (set) {
-                        var propName = toCamelCase(name);
-                        this[propName] = newValue;
-                    }
-                    var watchAttributes = this.constructor.watchAttributes;
-                    if (watchAttributes && watchAttributes[name]) {
-                        var methodToCall = watchAttributes[name];
-                        if (this.__connected) {
-                            if (typeof this[methodToCall] === 'function') {
-                                this[methodToCall]({ old: oldValue, new: newValue });
-                            }
-                        }
-                    }
-                }
-            };
-            class_1.prototype.connectedCallback = function () {
-                this.__render();
-                var parentProto = Object.getPrototypeOf(Object.getPrototypeOf(this)) || null;
-                if (parentProto && typeof parentProto.connectedCallback === 'function') {
-                    parentProto.connectedCallback.call(this);
-                }
-                this.__connected = true;
-                addEventListeners(this);
-                initializeProps(this);
-            };
-            class_1.prototype.__render = function () {
-                if (this.__connected)
-                    return;
-                var template = document.createElement('template');
-                var style = "".concat(args.style ? "<style>".concat(args.style, "</style>") : '');
-                template.innerHTML = "".concat(style).concat(args.template ? args.template : '');
-                (this.showShadowRoot ? this.shadowRoot : this).appendChild(document.importNode(template.content, true));
-            };
-            return class_1;
-        }(target));
-        if (!customElements.get(tag)) {
-            customElements.define(tag, customElement);
-        }
-        return customElement;
-    };
-};
-
-var Watch = function (attrName) {
-    return function (target, propertyName) {
-        if (!target.constructor.watchAttributes) {
-            target.constructor.watchAttributes = {};
-        }
-        target.constructor.watchAttributes[toKebabCase(attrName)] = propertyName;
-        if (!target.constructor.propsInit) {
-            target.constructor.propsInit = {};
-        }
-        target.constructor.propsInit[attrName] = null;
-    };
-};
-
-var Toggle = function () {
-    return function (target, propName) {
-        function get() {
-            var _this = this;
-            var getAttribute = function (attrName) {
-                if (_this.hasAttribute(attrName)) {
-                    var attrValue = _this.getAttribute(attrName);
-                    if (/^(true|false|^$)$/.test(attrValue)) {
-                        return attrValue === 'true' || attrValue === '';
-                    }
-                    else {
-                        return false;
-                    }
-                }
-                return false;
-            };
-            return getAttribute(propName);
-        }
-        function set(value) {
-            var oldValue = value;
-            if (value !== null && value !== undefined) {
-                switch (typeof value) {
-                    case 'boolean':
-                        break;
-                    case 'string':
-                        if (/^(true|false|^$)$/.test(value)) {
-                            value = oldValue === 'true' || oldValue === '';
-                        }
-                        else {
-                            console.warn("TypeError: Cannot set boolean toggle property '".concat(propName, "' to '").concat(value, "'"));
-                            value = false;
-                        }
-                        break;
-                    default:
-                        throw new TypeError("Cannot set boolean toggle property '".concat(propName, "' to '").concat(value, "'"));
-                }
-            }
-            if (this.__connected) {
-                this.props[propName] = value || false;
-                if (oldValue !== '' && oldValue !== null) {
-                    this.setAttribute(propName, value);
-                }
-                else {
-                    if (value) {
-                        this.setAttribute(propName, '');
-                    }
-                    else {
-                        this.removeAttribute(propName);
-                    }
-                }
-            }
-            else {
-                if (!this.hasAttribute(toKebabCase(propName))) {
-                    this.constructor.propsInit[propName] = value;
-                }
-            }
-        }
-        if (!target.constructor.propsInit) {
-            target.constructor.propsInit = {};
-        }
-        target.constructor.propsInit[propName] = null;
-        Object.defineProperty(target, propName, { get: get, set: set });
-    };
-};
-
-export { CustomElement, Dispatch, Listen, Prop, Toggle, Watch, addEventListeners, initializeProps };
-//# sourceMappingURL=custom-elements-ts.js.map

package/esm5/custom-elements-ts.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"custom-elements-ts.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/esm5/index.d.ts

@@ -1,5 +0,0 @@
-export * from './custom-element';
-export * from './watch';
-export * from './prop';
-export * from './toggle';
-export * from './listen';

package/esm5/listen.d.ts

@@ -1,17 +0,0 @@
-interface ListenerMetadata {
-    eventName: string;
-    handler: (e: Event) => void;
-    selector?: string;
-}
-interface CustomEventOptions {
-    bubbles?: boolean;
-    composed?: boolean;
-    detail?: any;
-}
-interface DispatchEmitter {
-    emit(options?: CustomEventOptions): void;
-}
-declare const Listen: (eventName: string, selector?: string) => (target: any, methodName: string) => void;
-declare const addEventListeners: (target: any) => void;
-declare const Dispatch: (eventName?: string) => (target: HTMLElement, propertyName: string) => void;
-export { Listen, addEventListeners, DispatchEmitter, Dispatch, CustomEventOptions, ListenerMetadata, };

package/esm5/prop.d.ts

@@ -1,2 +0,0 @@
-export declare const Prop: () => any;
-export declare const initializeProps: (target: any) => void;

package/esm5/toggle.d.ts

@@ -1 +0,0 @@
-export declare const Toggle: () => any;

package/esm5/util.d.ts

@@ -1,4 +0,0 @@
-export declare const toKebabCase: (str: string) => string;
-export declare const toCamelCase: (str: string) => string;
-export declare const toDotCase: (str: string) => string;
-export declare const tryParseInt: (value: unknown) => unknown;

package/esm5/watch.d.ts

@@ -1 +0,0 @@
-export declare const Watch: (attrName: string) => (target: any, propertyName: string) => void;