ariadne_view_components 0.0.42-x64-mingw-ucrt → 0.0.44-x64-mingw-ucrt

data/app/assets/javascripts/clipboard_copy_component/clipboard-copy-component.d.ts

@@ -0,0 +1,4 @@
+import { Controller } from '@hotwired/stimulus';
+export default class ClipboardCopyComponent extends Controller {
+    copy(): void;
+}

data/app/assets/javascripts/rich_text_area_component/rich-text-area-component.d.ts

@@ -0,0 +1,6 @@
+import { Controller } from '@hotwired/stimulus';
+export default class RichTextArea extends Controller {
+    static targets: string[];
+    readonly editorTargets: [HTMLDivElement];
+    connect(): void;
+}

data/app/assets/javascripts/slideover_component/slideover-component.d.ts

@@ -0,0 +1,9 @@
+import { Controller } from '@hotwired/stimulus';
+export default class SlideoverComponent extends Controller {
+    static targets: string[];
+    readonly expandableTarget: HTMLDivElement;
+    readonly expandWrapperTarget: HTMLDivElement;
+    readonly slidePanelTargets: [HTMLDivElement];
+    readonly buttonWrapperTarget: HTMLDivElement;
+    toggle(): void;
+}

data/app/assets/javascripts/tab_container_component/tab-container-component.d.ts

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

data/app/assets/javascripts/tab_nav_component/tab-nav-component.d.ts

@@ -0,0 +1,9 @@
+import { Controller } from '@hotwired/stimulus';
+export default class TabNavComponent extends Controller {
+    static targets: string[];
+    readonly tabTargets: [HTMLAnchorElement];
+    SELECTED_CLASSES: string[];
+    UNSELECTED_CLASSES: string[];
+    connect(): void;
+    toggle(event: Event): void;
+}

data/app/assets/javascripts/time_ago_component/time-ago-component.d.ts

@@ -0,0 +1 @@
+import '@github/time-elements';

data/app/assets/javascripts/tooltip_component/tooltip-component.d.ts

@@ -0,0 +1,24 @@
+import { Controller } from '@hotwired/stimulus';
+import type { Instance, Placement } from '@popperjs/core';
+export default class TooltipComponent extends Controller {
+    static targets: string[];
+    readonly triggerTarget: HTMLElement;
+    readonly tooltipTarget: HTMLElement;
+    static values: {
+        placement: {
+            type: StringConstructor;
+            default: string;
+        };
+        offset: {
+            type: ArrayConstructor;
+            default: number[];
+        };
+    };
+    readonly placementValue: Placement;
+    readonly offsetValue: Array<number>;
+    popperInstance: Instance;
+    connect(): void;
+    disconnect(): void;
+    show(): void;
+    hide(): void;
+}

data/app/components/ariadne/ariadne-form.d.ts

@@ -0,0 +1,22 @@
+import { Controller } from '@hotwired/stimulus';
+import type { TemplateResult } from 'lit-html';
+type HTMLFormField = HTMLInputElement | HTMLSelectElement | HTMLTextAreaElement;
+export default class AriadneFormWith extends Controller {
+    static targets: string[];
+    readonly formFieldTargets: [HTMLFormField];
+    connect(): void;
+    disconnect(): void;
+    onBlur: (event: Event) => void;
+    onSubmit: (event: Event) => void;
+    validateForm(): boolean;
+    validateField(field: HTMLFormField): boolean;
+    shouldValidateField(field: HTMLFormField): boolean;
+    refreshErrorForInvalidField(field: HTMLFormField, isValid: boolean): void;
+    removeExistingErrorMessage(field: HTMLFormField): void;
+    showErrorForInvalidField(field: HTMLFormField): void;
+    buildFieldErrorHtml(field: HTMLFormField): string;
+    get formFields(): HTMLFormField[];
+    get firstInvalidField(): HTMLFormField | undefined;
+    getRenderString: (data: TemplateResult) => string;
+}
+export {};

data/app/components/ariadne/ariadne-form.js

@@ -0,0 +1,85 @@
+import { Controller } from '@hotwired/stimulus';
+import { html } from 'lit-html';
+class AriadneFormWith extends Controller {
+    constructor() {
+        super(...arguments);
+        this.onBlur = (event) => {
+            this.validateField(event.target);
+        };
+        this.onSubmit = (event) => {
+            var _a;
+            if (!this.validateForm()) {
+                event.preventDefault();
+                (_a = this.firstInvalidField) === null || _a === void 0 ? void 0 : _a.focus();
+            }
+        };
+        this.getRenderString = (data) => {
+            const { strings, values } = data;
+            const v = [...values, ''].map(e => (typeof e === 'object' ? this.getRenderString(e) : e));
+            return strings.reduce((acc, s, i) => acc + s + v[i], '');
+        };
+    }
+    connect() {
+        this.element.setAttribute('novalidate', 'true');
+        this.element.addEventListener('blur', this.onBlur, true);
+        this.element.addEventListener('submit', this.onSubmit);
+        this.element.addEventListener('ajax:beforeSend', this.onSubmit);
+    }
+    disconnect() {
+        this.element.removeEventListener('blur', this.onBlur);
+        this.element.removeEventListener('submit', this.onSubmit);
+        this.element.removeEventListener('ajax:beforeSend', this.onSubmit);
+    }
+    validateForm() {
+        let isValid = true;
+        // Not using `find` because we want to validate all the fields
+        for (const field of this.formFields) {
+            if (this.shouldValidateField(field) && !this.validateField(field))
+                isValid = false;
+        }
+        return isValid;
+    }
+    validateField(field) {
+        if (!this.shouldValidateField(field))
+            return true;
+        const isValid = field.checkValidity();
+        field.classList.toggle('invalid', !isValid);
+        this.refreshErrorForInvalidField(field, isValid);
+        return isValid;
+    }
+    shouldValidateField(field) {
+        return (!field.disabled &&
+            !field.classList.contains('ProseMirror') &&
+            !['file', 'reset', 'submit', 'button'].includes(field.type));
+    }
+    refreshErrorForInvalidField(field, isValid) {
+        this.removeExistingErrorMessage(field);
+        if (!isValid)
+            this.showErrorForInvalidField(field);
+    }
+    removeExistingErrorMessage(field) {
+        var _a;
+        const fieldContainer = field.closest('.field');
+        if (!fieldContainer)
+            return;
+        const existingErrorMessageElement = fieldContainer.querySelector('.error');
+        if (existingErrorMessageElement) {
+            (_a = existingErrorMessageElement === null || existingErrorMessageElement === void 0 ? void 0 : existingErrorMessageElement.parentNode) === null || _a === void 0 ? void 0 : _a.removeChild(existingErrorMessageElement);
+        }
+    }
+    showErrorForInvalidField(field) {
+        field.insertAdjacentHTML('afterend', this.buildFieldErrorHtml(field));
+    }
+    buildFieldErrorHtml(field) {
+        const data = html `<p class="error">${field.validationMessage}</p>`;
+        return this.getRenderString(data);
+    }
+    get formFields() {
+        return Array.from(this.formFieldTargets);
+    }
+    get firstInvalidField() {
+        return this.formFields.find(field => !field.checkValidity());
+    }
+}
+AriadneFormWith.targets = ['formField'];
+export default AriadneFormWith;

data/app/components/ariadne/ariadne-form.ts

@@ -0,0 +1,96 @@
+import {Controller} from '@hotwired/stimulus'
+import {html} from 'lit-html'
+import type {TemplateResult} from 'lit-html'
+
+type HTMLFormField = HTMLInputElement | HTMLSelectElement | HTMLTextAreaElement
+
+export default class AriadneFormWith extends Controller {
+  static targets = ['formField']
+  declare readonly formFieldTargets: [HTMLFormField]
+
+  connect() {
+    this.element.setAttribute('novalidate', 'true')
+    this.element.addEventListener('blur', this.onBlur, true)
+    this.element.addEventListener('submit', this.onSubmit)
+    this.element.addEventListener('ajax:beforeSend', this.onSubmit)
+  }
+
+  disconnect() {
+    this.element.removeEventListener('blur', this.onBlur)
+    this.element.removeEventListener('submit', this.onSubmit)
+    this.element.removeEventListener('ajax:beforeSend', this.onSubmit)
+  }
+
+  onBlur = (event: Event) => {
+    this.validateField(event.target as HTMLFormField)
+  }
+
+  onSubmit = (event: Event) => {
+    if (!this.validateForm()) {
+      event.preventDefault()
+      this.firstInvalidField?.focus()
+    }
+  }
+
+  validateForm() {
+    let isValid = true
+    // Not using `find` because we want to validate all the fields
+    for (const field of this.formFields) {
+      if (this.shouldValidateField(field) && !this.validateField(field)) isValid = false
+    }
+    return isValid
+  }
+
+  validateField(field: HTMLFormField) {
+    if (!this.shouldValidateField(field)) return true
+    const isValid = field.checkValidity()
+    field.classList.toggle('invalid', !isValid)
+    this.refreshErrorForInvalidField(field, isValid)
+    return isValid
+  }
+
+  shouldValidateField(field: HTMLFormField) {
+    return (
+      !field.disabled &&
+      !field.classList.contains('ProseMirror') &&
+      !['file', 'reset', 'submit', 'button'].includes(field.type)
+    )
+  }
+
+  refreshErrorForInvalidField(field: HTMLFormField, isValid: boolean) {
+    this.removeExistingErrorMessage(field)
+    if (!isValid) this.showErrorForInvalidField(field)
+  }
+
+  removeExistingErrorMessage(field: HTMLFormField) {
+    const fieldContainer = field.closest('.field')
+    if (!fieldContainer) return
+    const existingErrorMessageElement = fieldContainer.querySelector('.error')
+    if (existingErrorMessageElement) {
+      existingErrorMessageElement?.parentNode?.removeChild(existingErrorMessageElement)
+    }
+  }
+
+  showErrorForInvalidField(field: HTMLFormField) {
+    field.insertAdjacentHTML('afterend', this.buildFieldErrorHtml(field))
+  }
+
+  buildFieldErrorHtml(field: HTMLFormField) {
+    const data = html`<p class="error">${field.validationMessage}</p>`
+    return this.getRenderString(data)
+  }
+
+  get formFields(): HTMLFormField[] {
+    return Array.from(this.formFieldTargets)
+  }
+
+  get firstInvalidField() {
+    return this.formFields.find(field => !field.checkValidity())
+  }
+
+  getRenderString = (data: TemplateResult): string => {
+    const {strings, values} = data
+    const v = [...values, ''].map(e => (typeof e === 'object' ? this.getRenderString(e as TemplateResult) : e))
+    return strings.reduce((acc, s, i) => acc + s + v[i], '')
+  }
+}

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

@@ -0,0 +1,2 @@
+import './tab_container_component/tab-container-component';
+import './time_ago_component/time-ago-component';

data/app/components/ariadne/ariadne.js

@@ -0,0 +1,16 @@
+import { Application } from '@hotwired/stimulus';
+import AriadneForm from './ariadne-form';
+import ClipboardCopyComponent from './clipboard_copy_component/clipboard-copy-component';
+import RichTextAreaComponent from './rich_text_area_component/rich-text-area-component';
+import SlideoverComponent from './slideover_component/slideover-component';
+import TabNavComponent from './tab_nav_component/tab-nav-component';
+import TooltipComponent from './tooltip_component/tooltip-component';
+import './tab_container_component/tab-container-component';
+import './time_ago_component/time-ago-component';
+const application = Application.start();
+application.register('clipboard-copy-component', ClipboardCopyComponent);
+application.register('ariadne-form', AriadneForm);
+application.register('rich-text-area-component', RichTextAreaComponent);
+application.register('slideover-component', SlideoverComponent);
+application.register('tab-nav-component', TabNavComponent);
+application.register('tooltip-component', TooltipComponent);

data/app/components/ariadne/ariadne.ts

@@ -0,0 +1,21 @@
+import {Application} from '@hotwired/stimulus'
+
+import AriadneForm from './ariadne-form'
+
+import ClipboardCopyComponent from './clipboard_copy_component/clipboard-copy-component'
+import RichTextAreaComponent from './rich_text_area_component/rich-text-area-component'
+import SlideoverComponent from './slideover_component/slideover-component'
+import TabNavComponent from './tab_nav_component/tab-nav-component'
+import TooltipComponent from './tooltip_component/tooltip-component'
+
+import './tab_container_component/tab-container-component'
+import './time_ago_component/time-ago-component'
+
+const application = Application.start()
+
+application.register('clipboard-copy-component', ClipboardCopyComponent)
+application.register('ariadne-form', AriadneForm)
+application.register('rich-text-area-component', RichTextAreaComponent)
+application.register('slideover-component', SlideoverComponent)
+application.register('tab-nav-component', TabNavComponent)
+application.register('tooltip-component', TooltipComponent)

data/app/components/ariadne/avatar_component.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module Ariadne
+  # `Avatar` can be used to represent users.
+  #
+  # - Use the default circle avatar for users, and the square shape
+  # for or any other non-human avatars.
+  # - By default, `Avatar` will render a static `<img>`. To have `Avatar` function as a link, set the `href` which will wrap the `<img>` in a `<a>`.
+  # - Set `size` to update the height and width of the `Avatar` in pixels.
+  # - To stack multiple avatars together, use <%= link_to_component(Ariadne::AvatarStackComponent) %>.
+  #
+  # @accessibility
+  #   Images should have text alternatives that describe the information or function represented.
+  #   If the avatar functions as a link, provide alt text that helps convey the function. For instance,
+  #   if `Avatar` is a link to a user profile, the alt attribute should be `@kittenuser profile`
+  #   rather than `@kittenuser`.
+  #   [Learn more about best image practices (WAI Images)](https://www.w3.org/WAI/tutorials/images/)
+  class AvatarComponent < Ariadne::Component
+    DEFAULT_SIZE = 20
+    SMALL_THRESHOLD = 24
+
+    DEFAULT_SHAPE = :circle
+    SHAPE_OPTIONS = [DEFAULT_SHAPE, :square].freeze
+
+    SIZE_OPTIONS = [16, DEFAULT_SIZE, SMALL_THRESHOLD, 32, 40, 48, 80].freeze
+
+    DEFAULT_CLASSES = "ariadne-inline-block ariadne-rounded-full ariadne-ring-2 ariadne-ring-white"
+
+    # @example Default
+    #   <%= render(Ariadne::AvatarComponent.new(src: "http://placekitten.com/200/200", alt: "@kittenuser")) %>
+    #
+    # @example Square
+    #   <%= render(Ariadne::AvatarComponent.new(src: "http://placekitten.com/200/200", alt: "@kittenuser", shape: :square)) %>
+    #
+    # @example Link
+    #   <%= render(Ariadne::AvatarComponent.new(href: "#", src: "http://placekitten.com/200/200", alt: "@kittenuser profile")) %>
+    #
+    # @example With size
+    #   <%= render(Ariadne::AvatarComponent.new(src: "http://placekitten.com/200/200", alt: "@kittenuser", size: 16)) %>
+    #   <%= render(Ariadne::AvatarComponent.new(src: "http://placekitten.com/200/200", alt: "@kittenuser", size: 20)) %>
+    #   <%= render(Ariadne::AvatarComponent.new(src: "http://placekitten.com/200/200", alt: "@kittenuser", size: 24)) %>
+    #   <%= render(Ariadne::AvatarComponent.new(src: "http://placekitten.com/200/200", alt: "@kittenuser", size: 32)) %>
+    #   <%= render(Ariadne::AvatarComponent.new(src: "http://placekitten.com/200/200", alt: "@kittenuser", size: 40)) %>
+    #   <%= render(Ariadne::AvatarComponent.new(src: "http://placekitten.com/200/200", alt: "@kittenuser", size: 48)) %>
+    #   <%= render(Ariadne::AvatarComponent.new(src: "http://placekitten.com/200/200", alt: "@kittenuser", size: 80)) %>
+    #
+    # @param src [String] The source url of the avatar image.
+    # @param alt [String] Passed through to alt on img tag.
+    # @param size [Integer] <%= one_of(Ariadne::AvatarComponent::SIZE_OPTIONS) %>
+    # @param shape [Symbol] Shape of the avatar. <%= one_of(Ariadne::AvatarComponent::SHAPE_OPTIONS) %>
+    # @param href [String] The URL to link to. If used, component will be wrapped by an `<a>` tag.
+    # @param classes [String] <%= link_to_classes_docs %>
+    # @param attributes [Hash] <%= link_to_attributes_docs %>
+    def initialize(src:, alt:, size: DEFAULT_SIZE, shape: DEFAULT_SHAPE, href: nil, classes: "", attributes: {})
+      @tag = :img
+      @href = href
+
+      @classes = merge_class_names(
+        DEFAULT_CLASSES,
+        classes,
+      )
+
+      @attributes = attributes
+      @attributes[:src] = src
+      @attributes[:alt] = alt
+      @attributes[:size] = fetch_or_raise(SIZE_OPTIONS, size)
+      @attributes[:height] = @attributes[:size]
+      @attributes[:width] = @attributes[:size]
+    end
+
+    def call
+      if @href
+        render(Ariadne::LinkComponent.new(href: @href, classes: @classes, attributes: @attributes)) do
+          render(Ariadne::BaseComponent.new(tag: @tag)) { content }
+        end
+      else
+        render(Ariadne::BaseComponent.new(tag: @tag, classes: @classes, attributes: @attributes)) { content }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,12 @@
+<%= render Ariadne::BaseComponent.new(tag: @tag, classes: @classes, attributes: @attributes) do %>
+  <% if tooltipped? %>
+    <%= tooltip.to_s %>
+    <% avatars.each_with_index do |avatar, i| %>
+      <%= avatar %>
+    <% end %>
+  <% else %>
+    <% avatars.each_with_index do |avatar, i| %>
+      <%= avatar %>
+    <% end %>
+  <% end %>
+<% end %>

data/app/components/ariadne/avatar_stack_component.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module Ariadne
+  # Use `AvatarStack` to stack multiple avatars together.
+  class AvatarStackComponent < Ariadne::Component
+    ALIGN_DEFAULT = :left
+    ALIGN_OPTIONS = [ALIGN_DEFAULT, :right].freeze
+
+    DEFAULT_TAG = :div
+    TAG_OPTIONS = [DEFAULT_TAG, :span].freeze
+
+    DEFAULT_BODY_TAG = :div
+    BODY_TAG_OPTIONS = [DEFAULT_BODY_TAG, :span].freeze
+
+    # `Tooltip` that appears on mouse hover or keyboard focus over the stack.
+    #
+    # @param tag [Symbol, String] The rendered tag name
+    # @param text [String] The text content of the tooltip. This should be brief and no longer than a sentence.
+    # @param direction [Symbol] <%= one_of(Ariadne::TooltipComponent::VALID_PLACEMENTS) %>
+    # @param classes [String] <%= link_to_classes_docs %>
+    # @param attributes [Hash] Same arguments as <%= link_to_component(Ariadne::TooltipComponent) %>.
+    renders_one :tooltip, lambda { |tag: Ariadne::TooltipComponent::DEFAULT_TAG, text:, direction: Ariadne::TooltipComponent::DEFAULT_PLACEMENT, classes: "", attributes: {}|
+      raise ArgumentError, "Avatar stacks with a tooltip must have a unique `id` set." if @id.blank?
+
+      Ariadne::TooltipComponent.new(for_id: @id, tag: tag, text: text, direction: direction, type: :label, classes: classes, attributes: attributes)
+    }
+
+    # Required list of stacked avatars.
+    #
+    # @param classes [String] <%= link_to_classes_docs %>
+    # @param attributes [Hash] <%= link_to_attributes_docs %>
+    renders_many :avatars, "Ariadne::AvatarComponent"
+
+    DEFAULT_CLASSES = "ariadne-flex ariadne--space-x-2 ariadne-overflow-hidden"
+
+    # @example Default
+    #   <%= render(Ariadne::AvatarStackComponent.new) do |c| %>
+    #     <% c.with_avatar(src: "http://placekitten.com/200/200", alt: "@kittenuser") %>
+    #     <% c.with_avatar(src: "http://placekitten.com/200/200", alt: "@kittenuser") %>
+    #     <% c.with_avatar(src: "http://placekitten.com/200/200", alt: "@kittenuser") %>
+    #   <% end  %>
+    #
+    # @example Align right
+    #   <%= render(Ariadne::AvatarStackComponent.new(align: :right)) do |c| %>
+    #     <% c.with_avatar(src: "http://placekitten.com/200/200", alt: "@kittenuser") %>
+    #     <% c.with_avatar(src: "http://placekitten.com/200/200", alt: "@kittenuser") %>
+    #     <% c.with_avatar(src: "http://placekitten.com/200/200", alt: "@kittenuser") %>
+    #   <% end  %>
+    #
+    # @param tag [Symbol] <%= one_of(Ariadne::AvatarStackComponent::TAG_OPTIONS) %>
+    # @param align [Symbol] <%= one_of(Ariadne::AvatarStackComponent::ALIGN_OPTIONS) %>
+    # @param classes [String] <%= link_to_classes_docs %>
+    # @param attributes [Hash] <%= link_to_attributes_docs %>
+    def initialize(tag: DEFAULT_TAG, align: ALIGN_DEFAULT, classes: "", attributes: {})
+      @tag = check_incoming_tag(DEFAULT_TAG, tag)
+      @align = fetch_or_raise(ALIGN_OPTIONS, align)
+      @classes = merge_class_names(
+        DEFAULT_CLASSES,
+        classes,
+      )
+
+      @attributes = attributes
+      @attributes[:id] ||= "avatar-stack-#{SecureRandom.hex(4)}"
+      @id = @attributes[:id]
+    end
+
+    def render?
+      avatars.any?
+    end
+
+    def tooltipped?
+      tooltip.present?
+    end
+  end
+end

data/app/components/ariadne/base_button.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module Ariadne
+  # Use `BaseButton` to render an unstyled `<button>` tag that can be customized.
+  class BaseButton < Ariadne::Component
+    DEFAULT_TAG = :button
+    TAG_OPTIONS = [DEFAULT_TAG, :a, :summary].freeze
+
+    DEFAULT_TYPE = :button
+    TYPE_SUBMIT = :submit
+    VALID_TYPES = [DEFAULT_TYPE, :reset, TYPE_SUBMIT].freeze
+
+    SIZE_CLASS_MAPPINGS = {
+      xs: "ariadne-px-2.5 ariadne-py-1.5 ariadne-text-xs ariadne-font-medium ariadne-rounded",
+      sm: "ariadne-px-3 ariadne-py-2 ariadne-text-sm ariadne-leading-4 ariadne-font-medium ariadne-rounded-m",
+      md: "ariadne-px-4 ariadne-py-2 ariadne-text-sm ariadne-font-medium ariadne-rounded-md",
+      lg: "ariadne-px-4 ariadne-py-2 ariadne-text-base ariadne-font-medium ariadne-rounded-md",
+      xl: "ariadne-px-6 ariadne-py-3 ariadne-text-base ariadne-font-medium ariadne-rounded-md",
+    }.freeze
+    VALID_SIZES = SIZE_CLASS_MAPPINGS.keys.freeze
+
+    DEFAULT_CLASSES = "ariadne-items-center ariadne-border ariadne-shadow-sm focus:ariadne-outline-none focus:ariadne-ring-2 focus:ariadne-ring-offset-2"
+    DEFAULT_NUDE_CLASSES = "focus:ariadne-outline-none focus:ariadne-ring-2 focus:ariadne-ring-offset-2"
+
+    DEFAULT_SIZE = :md
+
+    # @example Setting the size
+    #   <%= render(Ariadne::BaseButton.new(size: :xs)) { "I am an extra small button!" } %>
+    #   <%= render(Ariadne::BaseButton.new(size: :sm)) { "I am a small button!" } %>
+    #   <%= render(Ariadne::BaseButton.new(size: :md)) { "I am a medium button!" } %>
+    #   <%= render(Ariadne::BaseButton.new(size: :lg)) { "I am a large button!" } %>
+    #   <%= render(Ariadne::BaseButton.new(size: :xl)) { "I am an extra large button!" } %>
+    #
+    # @param tag [Symbol] <%= one_of(Ariadne::BaseButton::TAG_OPTIONS) %>
+    # @param type [Symbol] <%= one_of(Ariadne::BaseButton::VALID_TYPES) %>
+    # @param size [Symbol] <%= one_of(Ariadne::BaseButton::VALID_SIZES) %>
+    # @param classes [String] <%= link_to_classes_docs %>
+    # @param attributes [Hash] <%= link_to_attributes_docs %>
+    def initialize(
+      tag: DEFAULT_TAG,
+      type: DEFAULT_TYPE,
+      size: DEFAULT_SIZE,
+      classes: "",
+      attributes: {}
+    )
+      @attributes = attributes
+      @tag = fetch_or_raise(TAG_OPTIONS, tag)
+      @size = fetch_or_raise(VALID_SIZES, size)
+
+      if button?
+        @attributes[:type] = fetch_or_raise(VALID_TYPES, type)
+        @classes = merge_class_names(DEFAULT_CLASSES, SIZE_CLASS_MAPPINGS[@size], classes)
+      else
+        @classes = merge_class_names(DEFAULT_NUDE_CLASSES, SIZE_CLASS_MAPPINGS[@size], classes)
+      end
+    end
+
+    def call
+      render(Ariadne::BaseComponent.new(tag: @tag, classes: @classes, attributes: @attributes)) { content }
+    end
+
+    private def link?(type)
+      type == :link
+    end
+
+    private def button?
+      @tag == :button
+    end
+  end
+end

data/app/components/ariadne/base_component.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Ariadne
+  # All Ariadne ViewComponents accept a standard set of options: classes, which match Tailwind CSS classes, and attributes, which match HTML attributes..
+  #
+  # Under the hood, any-non class attributes is passed to Rails' [`tag`](https://api.rubyonrails.org/classes/ActionView/Helpers/TagHelper.html#method-i-tag)
+  # (for self-closing tags) or [`content_tag`](https://api.rubyonrails.org/classes/ActionView/Helpers/TagHelper.html#method-i-content_tag).
+  class BaseComponent < Ariadne::Component
+    SELF_CLOSING_TAGS = [:area, :base, :br, :col, :embed, :hr, :img, :input, :link, :meta, :param, :source, :track, :wbr].freeze
+
+    def initialize(tag:, classes: "", attributes: {})
+      @tag = tag
+
+      @attributes = validate_attributes(tag: tag, attributes: attributes) || {}
+      @attributes[:"data-ariadne-view-component"] = true
+
+      classes = @attributes.fetch(:classes, "") if classes.blank?
+      @classes = validate_merge_class_names(classes) || {}
+      @content_tag_args = {}
+    end
+
+    def call
+      options = @attributes.merge(@classes)
+      if SELF_CLOSING_TAGS.include?(@tag)
+        tag(@tag, options)
+      else
+        content_tag(@tag, content, options)
+      end
+    end
+
+    private def validate_merge_class_names(classes)
+      return if classes.blank?
+
+      { class: Ariadne::ViewComponents.tailwind_merger.merge(classes) }
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+<%= render Ariadne::NarrowContainerComponent.new do %>
+  <%= render Ariadne::BaseComponent.new(tag: @tag, classes: @classes, attributes: @attributes) do %>
+    <% if icon.present? %>
+      <%= icon %>
+    <% elsif image.present? %>
+      <%= image %>
+    <% end %>
+    <%= heading %>
+    <% if description.present? %>
+      <%= description %>
+    <% end %>
+    <%= content %>
+    <div class="ariadne-mt-8 ariadne-flex ariadne-justify-center">
+      <% if primary_action.present? %>
+        <div class="ariadne-inline-flex ariadne-rounded-md shadow">
+          <%= primary_action %>
+        </div>
+      <% end %>
+      <% if secondary_action.present? %>
+        <div class="ariadne-ml-3 ariadne-inline-flex">
+          <%= secondary_action %>
+        </div>
+      <% end %>
+    </div>
+  <% end %>
+<% end %>