ariadne_view_components 0.0.48-x86_64-linux → 0.0.49-x86_64-linux

data/app/components/ariadne/outlet_manager_controller/outlet_manager_controller.ts

@@ -0,0 +1,278 @@
+import {Controller} from '@hotwired/stimulus'
+
+type TOutletEventLookup = boolean | {[k: string]: TOutletEventLookup}
+
+export type TOutletChangeData<T> =
+  | {
+      eventKey?: string
+      data?: T
+    }
+  | undefined
+
+export default class OutletManagerController<T> extends Controller {
+  static values = {
+    outletEvents: Array,
+  }
+
+  declare readonly outletEventsValue: Array<string>
+  declare readonly hasOutletEventsValue: boolean
+
+  static outlets = ['toggleable', 'options', 'string-match']
+  declare readonly toggleableOutlets: Array<OutletManagerController<T>>
+  declare readonly hasToggleableOutlet: boolean
+  declare readonly optionsOutlets: Array<OutletManagerController<T>>
+  declare readonly hasOptionsOutlet: boolean
+  declare readonly stringMatchOutlets: Array<OutletManagerController<T>>
+  declare readonly hasStringMatchOutlet: boolean
+
+  outletEventsLookup: TOutletEventLookup | null = null
+
+  static domEvents: {[k: string]: boolean} = {
+    abort: true,
+    afterprint: true,
+    animationend: true,
+    animationiteration: true,
+    animationstart: true,
+    beforeprint: true,
+    beforeunload: true,
+    blur: true,
+    canplay: true,
+    canplaythrough: true,
+    change: true,
+    click: true,
+    contextmenu: true,
+    copy: true,
+    cut: true,
+    dblclick: true,
+    drag: true,
+    dragend: true,
+    dragenter: true,
+    dragleave: true,
+    dragover: true,
+    dragstart: true,
+    drop: true,
+    durationchange: true,
+    ended: true,
+    error: true,
+    focus: true,
+    focusin: true,
+    focusout: true,
+    fullscreenchange: true,
+    fullscreenerror: true,
+    hashchange: true,
+    input: true,
+    invalid: true,
+    keydown: true,
+    keypress: true,
+    keyup: true,
+    load: true,
+    loadeddata: true,
+    loadedmetadata: true,
+    loadstart: true,
+    message: true,
+    mousedown: true,
+    mouseenter: true,
+    mouseleave: true,
+    mousemove: true,
+    mouseover: true,
+    mouseout: true,
+    mouseup: true,
+    mousewheel: true,
+    offline: true,
+    online: true,
+    open: true,
+    pagehide: true,
+    pageshow: true,
+    paste: true,
+    pause: true,
+    play: true,
+    playing: true,
+    popstate: true,
+    progress: true,
+    ratechange: true,
+    resize: true,
+    reset: true,
+    scroll: true,
+    search: true,
+    seeked: true,
+    seeking: true,
+    select: true,
+    show: true,
+    stalled: true,
+    storage: true,
+    submit: true,
+    suspend: true,
+    timeupdate: true,
+    toggle: true,
+    touchcancel: true,
+    touchend: true,
+    touchmove: true,
+    touchstart: true,
+    transitionend: true,
+    unload: true,
+    volumechange: true,
+    waiting: true,
+    wheel: true,
+  }
+
+  eventRecords: Map<Event, boolean> = new Map()
+
+  getOutlets(): Array<OutletManagerController<T>> | null | void {
+    return null
+  }
+
+  outletUpdate(event: Event, data: TOutletChangeData<T>): void {}
+
+  getState(): T {
+    return null as T
+  }
+
+  connect() {
+    this.syncOutlets()
+  }
+
+  syncOutlets() {
+    const event = new Event('init')
+    this.sendToOutlets(event, {
+      data: this.getState(),
+      eventKey: this.getEventKey(event),
+    })
+  }
+
+  sendToOutlets(event: Event, updateTo: TOutletChangeData<T> = {}): void {
+    const eventKey = updateTo.eventKey ?? this.getEventKey(event)
+    const outlets = this.#outlets
+    if (outlets?.length) {
+      for (const index in outlets) {
+        const outlet = outlets[index]
+        if (outlet.isListeningForOutletEvent(eventKey) && !this.hasHeardEvent(event)) {
+          const isSameControllerType = this.identifier === outlet.identifier
+          outlet.outletUpdate(event, {eventKey, data: isSameControllerType ? updateTo.data : undefined})
+        }
+      }
+    }
+  }
+
+  isListeningForOutletEvent(eventTypes: string) {
+    const eventTypeNames = eventTypes.split('-')
+
+    if (!eventTypeNames.length) {
+      return false
+    }
+
+    let lookup = this.outletEvents
+    for (let i = 0; i < eventTypeNames.length; i++) {
+      const name = eventTypeNames[i]
+      if (typeof lookup === 'boolean') {
+        return lookup
+      }
+
+      const hasWildCard = lookup['*'] !== undefined
+      let nextKey = name
+      if (hasWildCard) {
+        nextKey = '*'
+      } else {
+        const isListeningForDOMEvent = lookup.domEvent !== undefined
+        if (isListeningForDOMEvent && !this.isDOMEventName(name)) {
+          return false
+        } else if (isListeningForDOMEvent) {
+          nextKey = 'domEvent'
+        }
+      }
+
+      if (!lookup[nextKey]) {
+        return false
+      }
+
+      lookup = lookup[nextKey]
+    }
+
+    return true
+  }
+
+  isDOMEventName(eventName: string) {
+    return OutletManagerController.domEvents[eventName]
+  }
+
+  getEventKey(event: Event) {
+    const pre = this.event_key_prefix
+    const post = this.event_key_postfix
+
+    const maybePreHyphen = pre ? '-' : ''
+    const maybePrefix = pre ?? ''
+    const maybePostHyphen = post ? '-' : ''
+    const maybePostfix = post ?? ''
+
+    return `${this.identifier}-${maybePrefix}${maybePreHyphen}${event.type}${maybePostHyphen}${maybePostfix}`
+  }
+
+  hasHeardEvent(event: Event) {
+    if (this.eventRecords.has(event)) {
+      return true
+    }
+
+    this.eventRecords.set(event, true)
+    setTimeout(() => this.eventRecords.delete(event))
+
+    return false
+  }
+
+  get event_key_prefix() {
+    return ''
+  }
+
+  get event_key_postfix() {
+    return ''
+  }
+
+  get outletEvents() {
+    if (!this.outletEventsLookup && this.hasOutletEventsValue) {
+      this.outletEventsLookup = this.outletEventsValue.reduce((acc, eventType) => {
+        let step = acc
+        eventType.split('-').forEach((eventTypeName, i, splitArr) => {
+          if (typeof step === 'boolean') {
+            return
+          }
+
+          if (i === splitArr.length - 1) {
+            step[eventTypeName] = true
+          } else if (step[eventTypeName] === undefined) {
+            step[eventTypeName] = {}
+          }
+
+          step = step[eventTypeName]
+        })
+
+        return acc
+      }, {} as TOutletEventLookup)
+    } else if (!this.outletEventsLookup) {
+      this.outletEventsLookup = {'*': true}
+    }
+
+    return this.outletEventsLookup
+  }
+
+  get #outlets(): Array<OutletManagerController<T>> | null | void {
+    const outlets = this.getOutlets()
+
+    if (outlets) {
+      return outlets
+    }
+
+    const defaultOutlets: Array<OutletManagerController<T>> = []
+
+    if (this.hasToggleableOutlet) {
+      defaultOutlets.push(...this.toggleableOutlets)
+    }
+
+    if (this.hasOptionsOutlet) {
+      defaultOutlets.push(...this.optionsOutlets)
+    }
+
+    if (this.hasStringMatchOutlet) {
+      defaultOutlets.push(...this.stringMatchOutlets)
+    }
+
+    return defaultOutlets
+  }
+}

data/app/components/ariadne/popover_component.html.erb

@@ -2,7 +2,6 @@
   <div class="<%= @base_classes %>">
     <%= base %>
   </div>
-  <div class="hidden ariadne-my-20 ariadne-w-20"></div>
   <div class="<%= @items_wrapper_classes %>" data-action="click->toggleable#toggle">
     <% items.each do |item| %>
       <%= item %>

data/app/components/ariadne/show_more_button_component.html.erb

@@ -3,7 +3,7 @@
     <%= @button_text %>
   <% end %>
   <div
-    class="ariadne-max-h-full aria-hidden:ariadne-max-h-0 ariadne-overflow-hidden ariadne-my-2" data-controller="toggleable" aria-hidden="true" data-toggleable-anti-attrs-value='["aria-hidden"]' data-toggleable-outlet="<%= @outlet %>">
+    class="ariadne-max-h-full aria-hidden:ariadne-max-h-0 ariadne-overflow-hidden ariadne-my-2 ariadne-border-solid ariadne-border-2 aria-selected:ariadne-hidden aria-selected:ariadne-border-green-300 aria-selected:ariadne-border-solid aria-selected:ariadne-border-2 ariadne-border-transparent ariadne-min-w-[21rem] ariadne-whitespace-nowrap ariadne-text-ellipsis" data-controller="toggleable" aria-hidden="true" data-toggleable-anti-attrs-value='["aria-hidden"]' data-toggleable-outlet="<%= @outlet %>">
     <% hiddens.each do |hidden| %>
       <%= hidden %>
     <% end %>

data/app/components/ariadne/string_match_controller/string_match_controller.d.ts

@@ -0,0 +1,27 @@
+import { TOutletChangeData } from '../outlet_manager_controller/outlet_manager_controller';
+import SyncedBooleanAttributesController from '../synced_boolean_attributes_controller/synced_boolean_attributes_controller';
+export interface StringMatchOutlet extends SyncedBooleanAttributesController<string> {
+    change: (event: Event, updateTo?: TOutletChangeData<string>) => void;
+}
+export default class StringMatchController extends SyncedBooleanAttributesController<string> implements StringMatchOutlet {
+    #private;
+    static outlets: string[];
+    static targets: string[];
+    static values: {
+        keyword: StringConstructor;
+        syncedAttrs: ArrayConstructor;
+        antiAttrs: ArrayConstructor;
+        protectAttrs: BooleanConstructor;
+        outletEvents: ArrayConstructor;
+    };
+    readonly matchTargets: Array<HTMLElement>;
+    readonly hasMatchTarget: boolean;
+    readonly emptyTarget: Element;
+    readonly hasEmptyTarget: boolean;
+    keywordValue: string;
+    change(event: Event, updateTo?: TOutletChangeData<string>): void;
+    getElementsToSync(): Element[] | null | undefined;
+    getValueForElement(element: Element): boolean;
+    getState(): string;
+    outletUpdate: (event: Event, updateTo?: TOutletChangeData<string>) => void;
+}

data/app/components/ariadne/string_match_controller/string_match_controller.js

@@ -0,0 +1,51 @@
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _StringMatchController_instances, _StringMatchController_compareKeywordToTargets;
+import SyncedBooleanAttributesController from '../synced_boolean_attributes_controller/synced_boolean_attributes_controller';
+class StringMatchController extends SyncedBooleanAttributesController {
+    constructor() {
+        super(...arguments);
+        _StringMatchController_instances.add(this);
+        this.outletUpdate = this.change;
+    }
+    change(event, updateTo = {}) {
+        var _a;
+        const value = (_a = updateTo.data) !== null && _a !== void 0 ? _a : event.currentTarget.value;
+        this.keywordValue = value;
+        __classPrivateFieldGet(this, _StringMatchController_instances, "m", _StringMatchController_compareKeywordToTargets).call(this);
+        this.sendToOutlets(event, Object.assign(Object.assign({}, updateTo), { data: this.keywordValue }));
+    }
+    getElementsToSync() {
+        return this.matchTargets;
+    }
+    getValueForElement(element) {
+        var _a, _b;
+        return (_b = (_a = element.innerText) === null || _a === void 0 ? void 0 : _a.toLowerCase().includes(this.keywordValue.toLowerCase())) !== null && _b !== void 0 ? _b : false;
+    }
+    getState() {
+        return this.keywordValue;
+    }
+}
+_StringMatchController_instances = new WeakSet(), _StringMatchController_compareKeywordToTargets = function _StringMatchController_compareKeywordToTargets() {
+    if (this.hasMatchTarget) {
+        let foundMatch = false;
+        for (let index in this.matchTargets) {
+            const target = this.matchTargets[index];
+            const value = this.getValueForElement(target);
+            this.updateAttributesForElement(target, value);
+            if (value) {
+                foundMatch = true;
+            }
+        }
+        if (this.hasEmptyTarget) {
+            this.emptyTarget.setAttribute('aria-hidden', String(foundMatch));
+        }
+    }
+};
+StringMatchController.outlets = SyncedBooleanAttributesController.outlets;
+StringMatchController.targets = ['match', 'empty'];
+StringMatchController.values = Object.assign(Object.assign({}, SyncedBooleanAttributesController.values), { keyword: String });
+export default StringMatchController;

data/app/components/ariadne/string_match_controller/string_match_controller.ts

@@ -0,0 +1,64 @@
+import {TOutletChangeData} from '../outlet_manager_controller/outlet_manager_controller'
+import SyncedBooleanAttributesController from '../synced_boolean_attributes_controller/synced_boolean_attributes_controller'
+
+export interface StringMatchOutlet extends SyncedBooleanAttributesController<string> {
+  change: (event: Event, updateTo?: TOutletChangeData<string>) => void
+}
+
+export default class StringMatchController
+  extends SyncedBooleanAttributesController<string>
+  implements StringMatchOutlet
+{
+  static outlets = SyncedBooleanAttributesController.outlets
+  static targets = ['match', 'empty']
+  static values = {
+    ...SyncedBooleanAttributesController.values,
+    keyword: String,
+  }
+
+  declare readonly matchTargets: Array<HTMLElement>
+  declare readonly hasMatchTarget: boolean
+
+  declare readonly emptyTarget: Element
+  declare readonly hasEmptyTarget: boolean
+
+  declare keywordValue: string
+
+  change(event: Event, updateTo: TOutletChangeData<string> = {}) {
+    const value = updateTo.data ?? (event.currentTarget as HTMLInputElement).value
+    this.keywordValue = value
+    this.#compareKeywordToTargets()
+    this.sendToOutlets(event, {...updateTo, data: this.keywordValue})
+  }
+  #compareKeywordToTargets() {
+    if (this.hasMatchTarget) {
+      let foundMatch = false
+      for (let index in this.matchTargets) {
+        const target = this.matchTargets[index]
+        const value = this.getValueForElement(target)
+        this.updateAttributesForElement(target, value)
+        if (value) {
+          foundMatch = true
+        }
+      }
+
+      if (this.hasEmptyTarget) {
+        this.emptyTarget.setAttribute('aria-hidden', String(foundMatch))
+      }
+    }
+  }
+
+  getElementsToSync(): Element[] | null | undefined {
+    return this.matchTargets
+  }
+
+  getValueForElement(element: Element) {
+    return (element as HTMLElement).innerText?.toLowerCase().includes(this.keywordValue.toLowerCase()) ?? false
+  }
+
+  getState() {
+    return this.keywordValue
+  }
+
+  outletUpdate = this.change
+}

data/app/components/ariadne/synced_boolean_attributes_controller/synced_boolean_attributes_controller.d.ts

@@ -0,0 +1,44 @@
+import OutletManagerController from '../outlet_manager_controller/outlet_manager_controller';
+export type TStimulusDispatchEvent<TDetails> = {
+    target?: Element | undefined;
+    detail?: TDetails | undefined;
+    prefix?: string | undefined;
+    bubbles?: boolean | undefined;
+    cancelable?: boolean | undefined;
+    preventDefault: () => void;
+};
+export type TBooleanValueDetail = {
+    value: boolean;
+};
+export interface TSyncAttrDetail extends TBooleanValueDetail {
+    attr: string;
+}
+export default class SyncedBooleanAttributesController<T> extends OutletManagerController<T> {
+    #private;
+    static values: {
+        syncedAttrs: ArrayConstructor;
+        antiAttrs: ArrayConstructor;
+        protectAttrs: BooleanConstructor;
+        outletEvents: ArrayConstructor;
+    };
+    readonly syncedAttrsValue: string[];
+    readonly hasSyncedAttrsValue: boolean;
+    readonly antiAttrsValue: string[];
+    readonly hasAntiAttrsValue: boolean;
+    readonly protectAttrsValue: boolean;
+    static removeOnFalseAttrs: {
+        [k: string]: boolean;
+    };
+    syncedAttrsLookup: {
+        [k: string]: boolean;
+    } | null;
+    antiAttrsLookup: {
+        [k: string]: boolean;
+    } | null;
+    getValueForElement(element: Element): boolean | null;
+    getElementsToSync(): Array<Element> | null | undefined;
+    connect(): void;
+    updateAttributesForElement(element: Element, value: boolean): void;
+    syncElementAttributes(): void;
+    validateAttrChange(dispatchEvent: TStimulusDispatchEvent<TSyncAttrDetail>): void;
+}

data/app/components/ariadne/synced_boolean_attributes_controller/synced_boolean_attributes_controller.js

@@ -0,0 +1,153 @@
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _SyncedBooleanAttributesController_instances, _SyncedBooleanAttributesController_isSyncedAttr, _SyncedBooleanAttributesController_isAntiAttr, _SyncedBooleanAttributesController_isAttr, _SyncedBooleanAttributesController_setAttrs, _SyncedBooleanAttributesController_getLookupForStringArray;
+import OutletManagerController from '../outlet_manager_controller/outlet_manager_controller';
+/*
+ This class isn't used directly by itself because it has no functionality. What it does is establishes
+ "synced attrs" and "anti-attrs" so that other controllers can extend this one and not worry about
+ implementing the logic themselves (and thus have duplicate logic all over our controllers)
+
+ To implement this, extend your controller with "SyncedBooleanAttributesController" then spread its
+ values into your controllers then implement:
+
+ export default class MyNewController extends SyncedBooleanAttributesController {
+  static values = {
+    ...SyncedBooleanAttributesController.values,
+    myString: String,
+  }
+}
+
+Also, consider the functions defined here ABOVE the connection() function. Those functions will
+give you control over how your controller can interact with other SyncedBooleanAttributeControllers.
+Not every controller needs them but you should consider them (description can be found in the functions)
+
+And don't forget that when you want to change an attr on an element, you should not do it manually.
+Instead run:
+this.updateAttributesForElement(element, value)
+This will let you take advantage of the ecosystem created by this base controller without any additional work
+*/
+class SyncedBooleanAttributesController extends OutletManagerController {
+    constructor() {
+        super(...arguments);
+        _SyncedBooleanAttributesController_instances.add(this);
+        this.syncedAttrsLookup = null;
+        this.antiAttrsLookup = null;
+    }
+    getValueForElement(element) {
+        // This function allows the base controller to access a given element's
+        // current status so the attributes can be set or compared. For example,
+        // you will want to make sure the attributes are added initially and are
+        // in sync with the controller's state. To ensure this, you can use the
+        // default connect() function or add "this.syncElementAttributes()" to your
+        // custom connect function. It'll look through your targets and get values for
+        // each then set the appropriate attrs and anti-attrs
+        return null;
+    }
+    getElementsToSync() {
+        // These are the elements your controller wants to keep in sync with the attrs
+        // Sometimes these are this.element, sometimes they're specific targets.
+        // Return them here so the base controller can automate some behaviors for you
+        return [];
+    }
+    connect() {
+        // This function will sync attrs and anti-attrs when the controller connects.
+        // The logic is abstracted to a function so you can override this connect
+        // function in favor of your own without having to duplicate the sync logic
+        this.syncElementAttributes();
+    }
+    updateAttributesForElement(element, value) {
+        // This is how you should update any synced or anti-synced attrs on your elements
+        // Do not do it manually unless you are very sure of what you're doing
+        if (this.hasSyncedAttrsValue) {
+            __classPrivateFieldGet(this, _SyncedBooleanAttributesController_instances, "m", _SyncedBooleanAttributesController_setAttrs).call(this, element, this.syncedAttrsValue, value);
+        }
+        if (this.hasAntiAttrsValue) {
+            __classPrivateFieldGet(this, _SyncedBooleanAttributesController_instances, "m", _SyncedBooleanAttributesController_setAttrs).call(this, element, this.antiAttrsValue, !value);
+        }
+    }
+    syncElementAttributes() {
+        var _a;
+        this.syncOutlets();
+        // Essentially just a "sync attrs and anti-attrs on mount" function
+        const elements = this.getElementsToSync();
+        if (elements === null || elements === void 0 ? void 0 : elements.length) {
+            for (let index in elements) {
+                const element = elements[index];
+                const value = (_a = this.getValueForElement(element)) !== null && _a !== void 0 ? _a : false;
+                this.updateAttributesForElement(element, value);
+            }
+        }
+    }
+    validateAttrChange(dispatchEvent) {
+        // If you protect your attrs, then this function will deny other controllers you specify from making changes to them.
+        // For example, if you want an item to disappear when it's selected, then your Options controller likely has an "aria-hidden"
+        // synced attr. If you use another attr to filter the list and then remove that filter, normally that would unhide your selected
+        // element. But if you have Options protect its attrs, the filter behavior won't be allowed to change it at any time and thus
+        // the element will remain hidden
+        const { target, detail } = dispatchEvent;
+        if (target && detail) {
+            const currentValue = this.getValueForElement(target);
+            if (currentValue !== null && this.protectAttrsValue && __classPrivateFieldGet(this, _SyncedBooleanAttributesController_instances, "m", _SyncedBooleanAttributesController_isAttr).call(this, detail.attr)) {
+                dispatchEvent.preventDefault();
+            }
+        }
+    }
+}
+_SyncedBooleanAttributesController_instances = new WeakSet(), _SyncedBooleanAttributesController_isSyncedAttr = function _SyncedBooleanAttributesController_isSyncedAttr(attr) {
+    var _a;
+    // Helper function to determine if the attr is synced
+    if (this.syncedAttrsLookup === null) {
+        this.syncedAttrsLookup = __classPrivateFieldGet(this, _SyncedBooleanAttributesController_instances, "m", _SyncedBooleanAttributesController_getLookupForStringArray).call(this, this.syncedAttrsValue);
+    }
+    return (_a = this.syncedAttrsLookup[attr]) !== null && _a !== void 0 ? _a : false;
+}, _SyncedBooleanAttributesController_isAntiAttr = function _SyncedBooleanAttributesController_isAntiAttr(attr) {
+    var _a;
+    // Helper function to determine if the attr is anti-synced
+    if (this.antiAttrsLookup === null) {
+        this.antiAttrsLookup = __classPrivateFieldGet(this, _SyncedBooleanAttributesController_instances, "m", _SyncedBooleanAttributesController_getLookupForStringArray).call(this, this.antiAttrsValue);
+    }
+    return (_a = this.antiAttrsLookup[attr]) !== null && _a !== void 0 ? _a : false;
+}, _SyncedBooleanAttributesController_isAttr = function _SyncedBooleanAttributesController_isAttr(attr) {
+    // Helper function to determine if an attr is known to a controller
+    return __classPrivateFieldGet(this, _SyncedBooleanAttributesController_instances, "m", _SyncedBooleanAttributesController_isAntiAttr).call(this, attr) || __classPrivateFieldGet(this, _SyncedBooleanAttributesController_instances, "m", _SyncedBooleanAttributesController_isSyncedAttr).call(this, attr);
+}, _SyncedBooleanAttributesController_setAttrs = function _SyncedBooleanAttributesController_setAttrs(element, attrs, value) {
+    // Attempts to change the attr for an element. However, it'll dispatch an event
+    // first so other controllers get the opportunity to deny it
+    const attrState = JSON.stringify(value);
+    for (let index in attrs) {
+        const attr = attrs[index];
+        const dispatchEvent = this.dispatch('attrChange', {
+            target: element,
+            detail: { attr, value },
+        });
+        if (!dispatchEvent.defaultPrevented) {
+            if (attrState === 'false' && SyncedBooleanAttributesController.removeOnFalseAttrs[attr]) {
+                element.removeAttribute(attr);
+            }
+            else {
+                element.setAttribute(attr, attrState);
+            }
+        }
+    }
+}, _SyncedBooleanAttributesController_getLookupForStringArray = function _SyncedBooleanAttributesController_getLookupForStringArray(arr) {
+    // Helper function to return an array of strings into an object for easy lookup
+    // While the arrays contained here are small, looking up attrs will happen often
+    // so I think it's worth the small sacrifice to memory
+    if (!(arr === null || arr === void 0 ? void 0 : arr.length)) {
+        return {};
+    }
+    return arr.reduce((acc, cur) => {
+        acc[cur] = true;
+        return acc;
+    }, {});
+};
+SyncedBooleanAttributesController.values = Object.assign(Object.assign({}, OutletManagerController.values), { syncedAttrs: Array, antiAttrs: Array, protectAttrs: Boolean });
+// Some attributes are only false in HTML if they don't exist
+// If included here, the property will be deleted on "false"
+SyncedBooleanAttributesController.removeOnFalseAttrs = {
+    checked: true,
+};
+export default SyncedBooleanAttributesController;