ariadne_view_components 0.0.59 → 0.0.65

data/app/components/ariadne/subheader_component.rb

@@ -1,65 +0,0 @@
-# frozen_string_literal: true
-
-module Ariadne
-  # A component to render a subheader with optional description below it and optional action
-  # components on the right side
-  class SubheaderComponent < Ariadne::Component
-    DEFAULT_TAGS = {
-      wrapper: :div,
-      actions: :div,
-      header: :h2,
-      description: :span,
-    }
-
-    DEFAULT_CLASSES = {
-      wrapper: "ariadne-border-b-2 ariadne-border-solid ariadne-border-black ariadne-border-opacity-20",
-      header: "",
-      actions: "",
-      description: "ariadne-text-black/50",
-    }
-
-    DEFAULT_ATTRIBUTES = {
-      wrapper: {},
-      header: {},
-      description: {},
-      actions: {},
-    }
-
-    renders_one :header, lambda { |tag: DEFAULT_TAGS[:header], classes: "", attributes: {}|
-      Ariadne::HeadingComponent.new(
-        tag: check_incoming_tag(DEFAULT_TAGS[:header], tag),
-        classes: merge_class_names(DEFAULT_CLASSES[:header], classes),
-        attributes: DEFAULT_ATTRIBUTES[:header].merge({ id: @header_id }).merge(attributes),
-      )
-    }
-
-    renders_one :description, lambda { |tag: DEFAULT_TAGS[:description], classes: "", attributes: {}|
-      Ariadne::BaseComponent.new(
-        tag: check_incoming_tag(DEFAULT_TAGS[:description], tag),
-        classes: merge_class_names(DEFAULT_CLASSES[:description], classes),
-        attributes: DEFAULT_ATTRIBUTES[:description]
-          .merge({ "aria-describedby": @header_id })
-          .merge(attributes),
-      )
-    }
-
-    renders_many :actions
-
-    # @example Default
-    #
-    #   <%= render(Ariadne::SubheaderComponent.new) { "Example" } %>
-    #
-    # @param tag [Symbol, String] The rendered tag name.
-    # @param classes [String] <%= link_to_classes_docs %>
-    # @param attributes [Hash] <%= link_to_attributes_docs %>
-    def initialize(tag: DEFAULT_TAGS[:wrapper], classes: "", id: "subheader-#{SecureRandom.uuid}", attributes: {})
-      @tag = check_incoming_tag(DEFAULT_TAGS[:wrapper], tag)
-      @header_id = id
-      @attributes = DEFAULT_ATTRIBUTES[:wrapper].merge(attributes)
-      @classes = merge_class_names(
-        DEFAULT_CLASSES[:wrapper],
-        classes,
-      )
-    end
-  end
-end

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

@@ -1,48 +0,0 @@
-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;
-    getSyncedAttrsForElement(element: Element): string[] | null;
-    getAntiAttrsForElement(element: Element): string[] | null;
-    getParsedAttributeForElement<T>(element: Element, attribute: string): T | null;
-    syncElementAttributes(): void;
-    validateAttrChange(dispatchEvent: TStimulusDispatchEvent<TSyncAttrDetail>): void;
-    doesElementHaveOnAttrs(element: Element): boolean;
-}

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

@@ -1,207 +0,0 @@
-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
-        const syncedAttrs = this.getSyncedAttrsForElement(element);
-        if (syncedAttrs === null || syncedAttrs === void 0 ? void 0 : syncedAttrs.length) {
-            __classPrivateFieldGet(this, _SyncedBooleanAttributesController_instances, "m", _SyncedBooleanAttributesController_setAttrs).call(this, element, syncedAttrs, value);
-        }
-        const antiAttrs = this.getAntiAttrsForElement(element);
-        if (antiAttrs === null || antiAttrs === void 0 ? void 0 : antiAttrs.length) {
-            __classPrivateFieldGet(this, _SyncedBooleanAttributesController_instances, "m", _SyncedBooleanAttributesController_setAttrs).call(this, element, antiAttrs, !value);
-        }
-    }
-    getSyncedAttrsForElement(element) {
-        const parsedAttrs = this.getParsedAttributeForElement(element, 'data-options-synced-attrs-value');
-        if (parsedAttrs) {
-            return parsedAttrs;
-        }
-        if (this.hasSyncedAttrsValue) {
-            return this.syncedAttrsValue;
-        }
-        return null;
-    }
-    getAntiAttrsForElement(element) {
-        const parsedAttrs = this.getParsedAttributeForElement(element, 'data-options-anti-attrs-value');
-        if (parsedAttrs) {
-            return parsedAttrs;
-        }
-        if (this.hasAntiAttrsValue) {
-            return this.antiAttrsValue;
-        }
-        return null;
-    }
-    getParsedAttributeForElement(element, attribute) {
-        const attr = element.getAttribute(attribute);
-        try {
-            if (attr === null) {
-                throw new Error('Bad attr');
-            }
-            return JSON.parse(attr);
-        }
-        catch (err) {
-            return null;
-        }
-    }
-    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 (const 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();
-            }
-        }
-    }
-    doesElementHaveOnAttrs(element) {
-        if (this.hasSyncedAttrsValue) {
-            for (let i = 0; i < this.syncedAttrsValue.length; i++) {
-                const attrName = this.syncedAttrsValue[i];
-                if (element.getAttribute(attrName) === 'true') {
-                    return true;
-                }
-            }
-        }
-        if (this.hasAntiAttrsValue) {
-            for (let i = 0; i < this.antiAttrsValue.length; i++) {
-                const attrName = this.antiAttrsValue[i];
-                const attrValue = element.getAttribute(attrName);
-                if (attrValue === 'false' || (SyncedBooleanAttributesController.removeOnFalseAttrs[attrName] && !attrValue)) {
-                    return true;
-                }
-            }
-        }
-        return false;
-    }
-}
-_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 (const 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;

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

@@ -1,256 +0,0 @@
-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
-}
-
-/*
- 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
-*/
-
-export default class SyncedBooleanAttributesController<T> extends OutletManagerController<T> {
-  static values = {
-    ...OutletManagerController.values,
-    syncedAttrs: Array, // Set option target attrs to true/false in agreement with the option's selected state
-    antiAttrs: Array, // Set option target attrs to true/false opposite of the option's selected state
-    protectAttrs: Boolean, // If the controller should block other SyncedBooleanAttributesController from changing its defined attrs
-  }
-
-  declare readonly syncedAttrsValue: string[]
-  declare readonly hasSyncedAttrsValue: boolean
-  declare readonly antiAttrsValue: string[]
-  declare readonly hasAntiAttrsValue: boolean
-  declare readonly protectAttrsValue: boolean
-
-  // Some attributes are only false in HTML if they don't exist
-  // If included here, the property will be deleted on "false"
-  static removeOnFalseAttrs: {[k: string]: boolean} = {
-    checked: true,
-  }
-
-  syncedAttrsLookup: {[k: string]: boolean} | null = null
-  antiAttrsLookup: {[k: string]: boolean} | null = null
-
-  getValueForElement(element: Element): boolean | null {
-    // 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(): Array<Element> | null | undefined {
-    // 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(): void {
-    // 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: Element, value: boolean) {
-    // 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
-    const syncedAttrs = this.getSyncedAttrsForElement(element)
-    if (syncedAttrs?.length) {
-      this.#setAttrs(element, syncedAttrs, value)
-    }
-
-    const antiAttrs = this.getAntiAttrsForElement(element)
-    if (antiAttrs?.length) {
-      this.#setAttrs(element, antiAttrs, !value)
-    }
-  }
-
-  getSyncedAttrsForElement(element: Element) {
-    const parsedAttrs = this.getParsedAttributeForElement<Array<string>>(element, 'data-options-synced-attrs-value')
-    if (parsedAttrs) {
-      return parsedAttrs
-    }
-
-    if (this.hasSyncedAttrsValue) {
-      return this.syncedAttrsValue
-    }
-
-    return null
-  }
-
-  getAntiAttrsForElement(element: Element) {
-    const parsedAttrs = this.getParsedAttributeForElement<Array<string>>(element, 'data-options-anti-attrs-value')
-    if (parsedAttrs) {
-      return parsedAttrs
-    }
-
-    if (this.hasAntiAttrsValue) {
-      return this.antiAttrsValue
-    }
-
-    return null
-  }
-
-  getParsedAttributeForElement<T>(element: Element, attribute: string) {
-    const attr = element.getAttribute(attribute)
-    try {
-      if (attr === null) {
-        throw new Error('Bad attr')
-      }
-
-      return JSON.parse(attr) as T
-    } catch (err) {
-      return null
-    }
-  }
-
-  syncElementAttributes() {
-    this.syncOutlets()
-    // Essentially just a "sync attrs and anti-attrs on mount" function
-    const elements = this.getElementsToSync()
-
-    if (elements?.length) {
-      for (const index in elements) {
-        const element = elements[index]
-        const value = this.getValueForElement(element) ?? false
-        this.updateAttributesForElement(element, value)
-      }
-    }
-  }
-
-  validateAttrChange(dispatchEvent: TStimulusDispatchEvent<TSyncAttrDetail>) {
-    // 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 && this.#isAttr(detail.attr)) {
-        dispatchEvent.preventDefault()
-      }
-    }
-  }
-
-  doesElementHaveOnAttrs(element: Element) {
-    if (this.hasSyncedAttrsValue) {
-      for (let i = 0; i < this.syncedAttrsValue.length; i++) {
-        const attrName = this.syncedAttrsValue[i]
-        if (element.getAttribute(attrName) === 'true') {
-          return true
-        }
-      }
-    }
-
-    if (this.hasAntiAttrsValue) {
-      for (let i = 0; i < this.antiAttrsValue.length; i++) {
-        const attrName = this.antiAttrsValue[i]
-        const attrValue = element.getAttribute(attrName)
-        if (attrValue === 'false' || (SyncedBooleanAttributesController.removeOnFalseAttrs[attrName] && !attrValue)) {
-          return true
-        }
-      }
-    }
-
-    return false
-  }
-
-  #isSyncedAttr(attr: string) {
-    // Helper function to determine if the attr is synced
-    if (this.syncedAttrsLookup === null) {
-      this.syncedAttrsLookup = this.#getLookupForStringArray(this.syncedAttrsValue)
-    }
-
-    return this.syncedAttrsLookup[attr] ?? false
-  }
-
-  #isAntiAttr(attr: string) {
-    // Helper function to determine if the attr is anti-synced
-    if (this.antiAttrsLookup === null) {
-      this.antiAttrsLookup = this.#getLookupForStringArray(this.antiAttrsValue)
-    }
-
-    return this.antiAttrsLookup[attr] ?? false
-  }
-
-  #isAttr(attr: string) {
-    // Helper function to determine if an attr is known to a controller
-    return this.#isAntiAttr(attr) || this.#isSyncedAttr(attr)
-  }
-
-  #setAttrs(element: Element, attrs: string[], value: boolean) {
-    // 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 (const index in attrs) {
-      const attr = attrs[index]
-
-      const dispatchEvent = this.dispatch('attrChange', {
-        target: element,
-        detail: {attr, value},
-      } as TStimulusDispatchEvent<TSyncAttrDetail>)
-
-      if (!dispatchEvent.defaultPrevented) {
-        if (attrState === 'false' && SyncedBooleanAttributesController.removeOnFalseAttrs[attr]) {
-          element.removeAttribute(attr)
-        } else {
-          element.setAttribute(attr, attrState)
-        }
-      }
-    }
-  }
-
-  #getLookupForStringArray(arr?: Array<string>) {
-    // 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?.length) {
-      return {}
-    }
-
-    return arr.reduce((acc, cur) => {
-      acc[cur] = true
-      return acc
-    }, {} as {[k: string]: boolean})
-  }
-}

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

@@ -1,3 +0,0 @@
-<%= render(Ariadne::BaseComponent.new(tag: @tag, classes: @classes, attributes: @attributes)) do %>
-  <%= text || content %>
-<% end %>

data/app/components/ariadne/tab_component.rb

@@ -1,98 +0,0 @@
-# frozen_string_literal: true
-
-module Ariadne
-  # This component is part of navigation components such as `Ariadne::TabContainerComponent`.
-  # and `Ariadne::TabNavComponent` and should not be used by itself.
-  #
-  # @accessibility
-  #   `TabComponent` renders the selected anchor tab with `aria-current="page"` by default.
-  #    When the selected tab does not correspond to the current page, such as in a nested inner tab, make sure to use aria-current="true"
-  class TabComponent < Ariadne::Component
-    DEFAULT_ARIA_CURRENT_FOR_ANCHOR = :page
-    ARIA_CURRENT_OPTIONS_FOR_ANCHOR = [true, DEFAULT_ARIA_CURRENT_FOR_ANCHOR].freeze
-
-    # Panel controlled by the Tab. This will not render anything in the tab itself.
-    # It will provide a accessor for the Tab's parent to call and render the panel
-    # content in the appropriate place.
-    #
-    # @param classes [String] <%= link_to_classes_docs %>
-    # @param attributes [Hash] <%= link_to_attributes_docs %>
-    renders_one :panel, lambda { |classes: "", attributes: {}|
-      attributes[:id] = @panel_id
-      tag = :div
-      attributes[:role] ||= :tabpanel
-      attributes[:hidden] = true unless @selected
-
-      label_present = aria("label", attributes) || aria("labelledby", attributes)
-      unless label_present
-        if @id.present?
-          attributes[:"aria-labelledby"] = @id
-        else
-          raise ArgumentError, "Panels must be labelled. Either set a unique `id` on the tab, or set an `aria-label` directly on the panel"
-        end
-      end
-
-      Ariadne::BaseComponent.new(tag: tag, classes: classes, attributes: attributes)
-    }
-
-    # The tab's text.
-    #
-    # @param kwargs [Hash] The same arguments as <%= link_to_component(Ariadne::Text) %>.
-    renders_one :text, Ariadne::Text
-    # TODO: test what hapenns with really long inbox names
-
-    attr_reader :selected, :id, :classes, :attributes
-
-    DEFAULT_CLASSES = "ariadne-border-transparent ariadne-text-gray-500 hover:ariadne-text-gray-700 hover:ariadne-border-gray-300 ariadne-whitespace-nowrap ariadne-py-4 ariadne-px-1 ariadne-border-b-2 ariadne-font-medium ariadne-text-sm"
-
-    # @example Default
-    #
-    #  <%= render(Ariadne::TabComponent.new(id: "pub-comment")) do |tab| %>
-    #    <% tab.text { "Public comment" } %>
-    #    <% tab.panel { "Public comment panel" } %>
-    #  <% end %>
-    # @param id [String] The unique ID of the tab.
-    # @param selected [Boolean] Whether the tab is selected or not.
-    # @param with_panel [Boolean] Whether the Tab has an associated panel.
-    # @param href [String] The link to navigate to when the tab is clicked.
-    # @param classes [String] <%= link_to_classes_docs %>
-    # @param attributes [Hash] <%= link_to_attributes_docs %>
-    def initialize(id: nil, selected: false, with_panel: false, href: nil, classes: "", attributes: {})
-      @id = id
-
-      @href = href
-      @selected = selected
-
-      @classes = merge_class_names(
-        DEFAULT_CLASSES,
-        classes,
-      )
-
-      @attributes = attributes
-      @attributes[:id] ||= @id
-
-      if with_panel # TODO: test
-        if @id.blank?
-          raise ArgumentError, "Tabs with panels must have a unique `id`"
-        end
-
-        @tag = :button
-        @attributes[:type] = :button
-        @attributes[:role] = :tab
-        @panel_id = "panel-#{@id}"
-        @attributes[:"aria-controls"] = @panel_id
-      else
-        @tag = :a
-      end
-
-      return unless @selected
-
-      if @tag == :a
-        aria_current = aria("current", attributes) || DEFAULT_ARIA_CURRENT_FOR_ANCHOR
-        @attributes[:"aria-current"] = fetch_or_raise(ARIA_CURRENT_OPTIONS_FOR_ANCHOR, aria_current)
-      else
-        @attributes[:"aria-selected"] = true
-      end
-    end
-  end
-end

data/app/components/ariadne/tab_container_component/tab-container-component.d.ts

@@ -1 +0,0 @@
-import '@github/tab-container-element';