@tylertech/forge-core 2.0.0

package/esm/custom-elements/decorators/foundation-property.js

@@ -0,0 +1,147 @@
+class FoundationPropertyOptions {
+    constructor(options) {
+        this.get = true;
+        this.set = true;
+        if (options) {
+            Object.assign(this, options);
+        }
+    }
+}
+// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
+const foundationPropertyNotFoundMessage = (className, propertyName) => `${className}\'s foundation does not contain the property \"${propertyName}\"`;
+// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
+const foundationNotFoundMessage = (className) => `${className} does not have a foundation`;
+function runIfVerified(target, propertyName, action) {
+    if (target._foundation) {
+        if (propertyName in target._foundation) {
+            return action();
+        }
+        else {
+            throw new Error(foundationPropertyNotFoundMessage(target.localName, propertyName));
+        }
+    }
+    else {
+        throw new Error(foundationNotFoundMessage(target.localName));
+    }
+}
+export function FoundationProperty(options) {
+    const allOptions = new FoundationPropertyOptions(options);
+    return (target, name, descriptor) => {
+        let defaultGet;
+        let defaultSet;
+        const propertyName = name;
+        const foundationPropertyName = ((options && options.name) || name).toString();
+        if (descriptor) {
+            defaultGet = descriptor.get;
+            defaultSet = descriptor.set;
+            descriptor.configurable = true;
+            descriptor.enumerable = true;
+            if (allOptions.set) {
+                descriptor.set = function (value) {
+                    return wireDescriptorSet(this, foundationPropertyName, attributes => {
+                        const desc = Object.getOwnPropertyDescriptor(target, foundationPropertyName);
+                        desc.set = attributes.set;
+                        Reflect.defineProperty(target, propertyName, desc);
+                        attributes.set(value);
+                    }, defaultSet);
+                };
+            }
+            if (allOptions.get) {
+                descriptor.get = function () {
+                    return wireDescriptorGet(this, foundationPropertyName, attributes => {
+                        const desc = Object.getOwnPropertyDescriptor(target, foundationPropertyName);
+                        desc.get = attributes.get;
+                        Reflect.defineProperty(target, propertyName, desc);
+                        return attributes.get();
+                    }, defaultGet);
+                };
+            }
+        }
+        else {
+            if (allOptions.set || allOptions.get) {
+                const attributes = { configurable: true, enumerable: true };
+                const get = {
+                    get() {
+                        const that = this;
+                        return wireDescriptorGet(that, foundationPropertyName, attrs => {
+                            let setter;
+                            // We have to wire the setter here as well
+                            if (allOptions.set) {
+                                setter = Object.assign({}, set);
+                            }
+                            Reflect.defineProperty(that, foundationPropertyName, Object.assign(Object.assign({ configurable: true, enumerable: true }, attrs), setter));
+                            return attrs.get();
+                        });
+                    }
+                };
+                const set = {
+                    set(value) {
+                        const that = this;
+                        return wireDescriptorSet(that, foundationPropertyName, attrs => {
+                            let getter;
+                            // We have to wire the getter here as well
+                            if (allOptions.get) {
+                                getter = Object.assign({}, get);
+                            }
+                            Reflect.defineProperty(that, foundationPropertyName, Object.assign(Object.assign({ configurable: true, enumerable: true }, attrs), getter));
+                            attrs.set(value);
+                        });
+                    }
+                };
+                if (allOptions.get) {
+                    Object.assign(attributes, Object.assign({}, get));
+                }
+                if (allOptions.set) {
+                    Object.assign(attributes, Object.assign({}, set));
+                }
+                Reflect.defineProperty(target, propertyName, attributes);
+            }
+        }
+    };
+}
+function setFoundation(target, value, propertyName) {
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    target._foundation[propertyName] = value;
+}
+function getFoundation(target, propertyName) {
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    return target._foundation[propertyName];
+}
+function wireDescriptorSet(target, propertyName, wireAction, defaultSet) {
+    let attributes;
+    if (defaultSet) {
+        attributes = {
+            set(value) {
+                defaultSet.call(target, value);
+                setFoundation(target, value, propertyName);
+            }
+        };
+    }
+    else {
+        attributes = {
+            set(value) {
+                setFoundation(target, value, propertyName);
+            }
+        };
+    }
+    return runIfVerified(target, propertyName, () => wireAction(attributes));
+}
+function wireDescriptorGet(target, propertyName, wireAction, defaultGet) {
+    let attributes;
+    if (defaultGet) {
+        attributes = {
+            get() {
+                defaultGet.call(target);
+                return getFoundation(target, propertyName);
+            }
+        };
+    }
+    else {
+        attributes = {
+            get() {
+                return getFoundation(target, propertyName);
+            }
+        };
+    }
+    return runIfVerified(target, propertyName, () => wireAction(attributes));
+}

package/esm/custom-elements/decorators/index.js

@@ -0,0 +1,2 @@
+export * from './custom-element';
+export * from './foundation-property';

package/esm/custom-elements/index.js

@@ -0,0 +1,2 @@
+export * from './decorators';
+export * from './component-utils';

package/esm/events/event-aware.js

@@ -0,0 +1,34 @@
+export class EventAware {
+    constructor() {
+        this._listenerMap = new Map();
+    }
+    _emit(type, data) {
+        const listeners = this._listenerMap.get(type);
+        if (listeners && listeners.length) {
+            listeners.forEach(cb => cb({ type, data }));
+        }
+    }
+    hasListeners(type) {
+        return type ? this._listenerMap.has(type) : this._listenerMap.size > 0;
+    }
+    addListener(type, listener) {
+        if (!this._listenerMap.has(type)) {
+            this._listenerMap.set(type, [listener]);
+        }
+        else {
+            const listeners = this._listenerMap.get(type);
+            if (listeners) {
+                listeners.push(listener);
+            }
+        }
+    }
+    removeListener(type, listener) {
+        const listeners = this._listenerMap.get(type);
+        if (listeners && listeners.length && listeners.includes(listener)) {
+            listeners.splice(listeners.indexOf(listener), 1);
+            if (!listeners.length) {
+                this._listenerMap.delete(type);
+            }
+        }
+    }
+}

package/esm/events/index.js

@@ -0,0 +1 @@
+export * from './event-aware';

package/esm/index.js

@@ -0,0 +1,13 @@
+/**
+ * @license
+ * Copyright (c) 2022 Tyler Technologies, Inc.
+ * License: Apache-2.0
+ */
+export * from './a11y';
+export * from './constants';
+export * from './custom-elements';
+export * from './events';
+export * from './message-list';
+export * from './scroll';
+export * from './services';
+export * from './utils';

package/esm/message-list/index.js

@@ -0,0 +1,2 @@
+export * from './message-list-entry';
+export * from './message-list';

package/esm/message-list/message-list-entry.js

@@ -0,0 +1,10 @@
+/**
+ * Represents a single message list entry containing a string message and its identifier.
+ */
+export class MessageListEntry {
+    constructor(message, identifier) {
+        this.message = message;
+        this.identifier = identifier;
+        this.originalMessage = message;
+    }
+}

package/esm/message-list/message-list.js

@@ -0,0 +1,112 @@
+import { MessageListEntry } from './message-list-entry';
+/**
+ * Represents a message list of any type. This class can be used to attach a string message to
+ * a generic identifier.
+ */
+export class MessageList {
+    constructor(useAutoEllipsis = true) {
+        this._useAutoEllipsis = true;
+        this._useAutoEllipsis = useAutoEllipsis;
+        this.reset();
+    }
+    /**
+       * True if ellipsis management occurs automatically. Default is true.
+       */
+    get useAutoEllipsis() {
+        return this._useAutoEllipsis;
+    }
+    set useAutoEllipsis(value) {
+        this._useAutoEllipsis = value;
+        this._updateMessage();
+    }
+    /**
+       * Adds a message to the entry map.
+       * @param {string} message The message string.
+       * @param {T} identifier The message identifier.
+       * @returns {MessageList<T>} A reference to `this` for chaining.
+       */
+    add(message, identifier) {
+        this._messages.push(new MessageListEntry(message, identifier));
+        this._updateMessage();
+        return this;
+    }
+    /**
+       * Removes a message using the provided identifier.
+       * @param {T} identifier The message identifier.
+       * @returns {MessageList<T>} A reference to `this` for chaining.
+       */
+    remove(identifier) {
+        const index = this._getMessageIndex(identifier);
+        if (index >= 0) {
+            this._messages.splice(index, 1);
+            this._updateMessage();
+        }
+        return this;
+    }
+    /**
+       * Updates an existing message value.
+       * @param {string} message The message string.
+       * @param {T} identifier The existing message identifier.
+       * @returns {MessageList<T>} A reference to `this` for chaining.
+       */
+    update(message, identifier) {
+        const index = this._getMessageIndex(identifier);
+        if (index >= 0) {
+            this._messages[index].message = message;
+            this._updateMessage();
+        }
+        return this;
+    }
+    /**
+       * Gets the number of messages in the list.
+       * @returns {number}
+       */
+    get messageCount() {
+        return this._messages.length;
+    }
+    /**
+       * Resets the message list to it's original state and removes all messages.
+       */
+    reset() {
+        this._messages = [];
+        this.message = '';
+    }
+    /**
+       * Determines if a message with the provided identifier exists.
+       * @param {T} identifier The message identifier.
+       */
+    hasMessage(identifier) {
+        return this._getMessageIndex(identifier) >= 0;
+    }
+    _updateMessage() {
+        this.message = '';
+        this._messages.forEach((item, index) => {
+            if (this.useAutoEllipsis) {
+                const hasEllipsis = item.message.substr(item.message.length - 3) === '...';
+                if (index === this._messages.length - 1) {
+                    if (!hasEllipsis) {
+                        item.message += '...';
+                    }
+                }
+                else if (hasEllipsis) {
+                    item.message = item.message.substr(0, item.message.length - 3);
+                }
+            }
+            else {
+                item.message = item.originalMessage;
+            }
+            this.message += item.message + (index < this._messages.length - 1 ? ', ' : '');
+        });
+        return this;
+    }
+    _getMessageIndex(identifier) {
+        let index = -1;
+        for (let i = 0; i < this._messages.length; i++) {
+            if (this._messages[i].identifier === identifier) {
+                index = i;
+                break;
+            }
+        }
+        return index;
+    }
+}

package/esm/scroll/index.js

@@ -0,0 +1,2 @@
+export * from './scroll-axis-observer';
+export * from './scroll-types';

package/esm/scroll/scroll-axis-observer.js

@@ -0,0 +1,114 @@
+import { EventAware } from '../events/event-aware';
+import { ScrollEvents, ScrollDirection } from './scroll-types';
+import { isDefined, throttle, isNumber } from '../utils';
+const DEFAULT_SCROLL_THROTTLE = 100;
+/**
+ * Provides facilties for observing and reacting to scroll events and information on a given element.
+ */
+export class ScrollAxisObserver extends EventAware {
+    constructor(_element, _config = {}) {
+        super();
+        this._element = _element;
+        this._config = _config;
+        this._axis = 'vertical';
+        this._scrollThreshold = 0;
+        this._lastScrollPosition = 0;
+        this._lastScrollTop = 0;
+        this._lastScrollLeft = 0;
+        this._isListening = false;
+        this._initialize();
+    }
+    destroy() {
+        this.stop();
+    }
+    start() {
+        if (!this._isListening) {
+            this._element.addEventListener('scroll', this._scrollListener);
+            this._isListening = true;
+        }
+    }
+    stop() {
+        this._element.removeEventListener('scroll', this._scrollListener);
+        this._isListening = false;
+    }
+    _initialize() {
+        if (this._config.throttle) {
+            const wait = this._config.throttleTime || DEFAULT_SCROLL_THROTTLE;
+            this._scrollListener = throttle(() => this._onScroll(), wait);
+        }
+        else {
+            this._scrollListener = () => this._onScroll();
+        }
+        if (!isDefined(this._config.paused) || !this._config.paused) {
+            this.start();
+        }
+        if (isDefined(this._config.axis)) {
+            this._axis = this._config.axis;
+        }
+        if (isDefined(this._config.scrollThreshold) && isNumber(this._config.scrollThreshold)) {
+            this._scrollThreshold = this._config.scrollThreshold;
+        }
+    }
+    _isScrollAxis() {
+        const isVertical = this._lastScrollTop !== this._element.scrollTop;
+        const isHorizontal = this._lastScrollLeft !== this._element.scrollLeft;
+        return (this._axis === 'vertical' && isVertical) || (this._axis === 'horizontal' && isHorizontal);
+    }
+    _onScroll() {
+        if (!this._isScrollAxis()) {
+            return;
+        }
+        const position = this.scrollPosition;
+        const direction = this._lastScrollPosition - position < 0 ? this._axis === 'vertical' ? ScrollDirection.Down : ScrollDirection.Right : this._axis === 'vertical' ? ScrollDirection.Up : ScrollDirection.Left;
+        this._emit(ScrollEvents.Scroll, { direction, position });
+        if (this._lastScrollPosition <= this._scrollThreshold && position > this._scrollThreshold) {
+            this._emit(ScrollEvents.Scrolled, true);
+        }
+        else if (this._lastScrollPosition >= this._scrollThreshold && (this._scrollThreshold > 0 ? position < this._scrollThreshold : position === 0)) {
+            this._emit(ScrollEvents.Scrolled, false);
+        }
+        const scrollStart = Math.round(position - this._scrollThreshold);
+        const scrollEnd = Math.round(this.scrollSize - position);
+        if (this._lastScrollPosition >= this._scrollThreshold && scrollStart <= 0) {
+            this._emit(ScrollEvents.ScrolledStart);
+        }
+        else if (this._lastScrollPosition <= (this.scrollSize - this._scrollThreshold) && scrollEnd <= this._scrollThreshold) {
+            this._emit(ScrollEvents.ScrolledEnd);
+        }
+        this._lastScrollPosition = position || 0;
+        this._lastScrollTop = this._element.scrollTop || 0;
+        this._lastScrollLeft = this._element.scrollLeft || 0;
+    }
+    get scrollPosition() {
+        return this._axis === 'vertical' ? this._element.scrollTop : this._element.scrollLeft;
+    }
+    get isScrolled() {
+        return this.scrollPosition > this._scrollThreshold;
+    }
+    get isScrolledStart() {
+        return this.scrollPosition === 0;
+    }
+    get isScrolledEnd() {
+        return this.scrollPosition === this._element.scrollWidth;
+    }
+    get isScrollable() {
+        if (this._axis === 'vertical') {
+            return this._element.scrollHeight > this._element.clientHeight;
+        }
+        return this._element.scrollWidth > this._element.clientWidth;
+    }
+    get scrollSize() {
+        return (this._axis === 'vertical' ? this._element.scrollHeight : this._element.scrollWidth) - this.elementSize;
+    }
+    get elementSize() {
+        return this._axis === 'vertical' ? this._element.clientHeight : this._element.clientWidth;
+    }
+    setScrollPosition(position) {
+        if (this._axis === 'vertical') {
+            this._element.scrollTop = position;
+        }
+        else {
+            this._element.scrollLeft = position;
+        }
+    }
+}

package/esm/scroll/scroll-types.js

@@ -0,0 +1,14 @@
+export var ScrollDirection;
+(function (ScrollDirection) {
+    ScrollDirection["Up"] = "up";
+    ScrollDirection["Down"] = "down";
+    ScrollDirection["Left"] = "left";
+    ScrollDirection["Right"] = "right";
+})(ScrollDirection || (ScrollDirection = {}));
+export var ScrollEvents;
+(function (ScrollEvents) {
+    ScrollEvents["Scroll"] = "scroll";
+    ScrollEvents["Scrolled"] = "scrolled";
+    ScrollEvents["ScrolledStart"] = "scrolled-start";
+    ScrollEvents["ScrolledEnd"] = "scrolled-end";
+})(ScrollEvents || (ScrollEvents = {}));

package/esm/services/index.js

@@ -0,0 +1 @@
+export * from './service-adapter';

package/esm/services/service-adapter.js

@@ -0,0 +1,12 @@
+export var ServiceRequestMethod;
+(function (ServiceRequestMethod) {
+    ServiceRequestMethod["GET"] = "GET";
+    ServiceRequestMethod["POST"] = "POST";
+    ServiceRequestMethod["PUT"] = "PUT";
+    ServiceRequestMethod["DELETE"] = "DELETE";
+    ServiceRequestMethod["PATCH"] = "PATCH";
+    ServiceRequestMethod["HEAD"] = "HEAD";
+    ServiceRequestMethod["CONNECT"] = "CONNECT";
+    ServiceRequestMethod["OPTIONS"] = "OPTIONS";
+    ServiceRequestMethod["TRACE"] = "TRACE";
+})(ServiceRequestMethod || (ServiceRequestMethod = {}));

package/esm/utils/a11y.js

@@ -0,0 +1,17 @@
+/** Constructs a visually hidden element and returns the element instance. */
+export function createVisuallyHiddenElement(attr = 'data-forge-live-announcer') {
+    const div = document.createElement('div');
+    div.style.position = 'absolute';
+    div.style.top = '0';
+    div.style.height = '1px';
+    div.style.width = '1px';
+    div.style.padding = '1px';
+    div.style.overflow = 'hidden';
+    div.style.clip = 'rect(0px, 0px, 0px, 0px)';
+    div.style.whiteSpace = 'nowrap';
+    div.style.border = '0px';
+    if (attr) {
+        div.setAttribute(attr, '');
+    }
+    return div;
+}

package/esm/utils/clipboard.js

@@ -0,0 +1,38 @@
+/** Copy the text value to the clipboard. */
+export function copyToClipboard(text) {
+    let textarea = _createTextareaAndSelect(text);
+    const copySuccessful = document.execCommand('copy');
+    if (textarea) {
+        document.body.removeChild(textarea);
+        textarea = null;
+    }
+    return copySuccessful;
+}
+/**
+ * Creates a hidden textarea element, sets its value from `text` property,
+ * and makes a selection on it.
+ */
+function _createTextareaAndSelect(text) {
+    var _a;
+    const textarea = document.createElement('textarea');
+    textarea.style.fontSize = '12pt';
+    textarea.style.border = '0';
+    textarea.style.clip = 'rect(0 0 0 0)';
+    textarea.style.height = '1px';
+    textarea.style.margin = '-1px';
+    textarea.style.overflow = 'hidden';
+    textarea.style.padding = '0';
+    textarea.style.position = 'absolute';
+    textarea.style.width = '1px';
+    textarea.style.outline = '0';
+    textarea.style.setProperty('-webkit-appearance', 'none');
+    textarea.style.setProperty('-moz-appearance', 'none');
+    const yPosition = window.pageYOffset || ((_a = document.documentElement) === null || _a === void 0 ? void 0 : _a.scrollTop);
+    textarea.style.top = yPosition + 'px';
+    textarea.setAttribute('readonly', '');
+    textarea.value = text;
+    document.body.appendChild(textarea);
+    textarea.select();
+    textarea.setSelectionRange(0, textarea.value.length);
+    return textarea;
+}