@pine-ds/core 5.0.0-mercury.0 → 5.0.0

package/dist/collection/components/pds-switch/pds-switch.js

@@ -1,16 +1,44 @@
 import { Host, h } from "@stencil/core";
-import { assignDescription, messageId } from "../../utils/form";
-import { PdsLabel } from "../_internal/pds-label/pds-label";
+import { assignDescription, isSpecTest, messageId, exposeTypeProperty } from "../../utils/form";
+import { danger } from "@pine-ds/icons/icons";
+import { inheritAriaAttributes, HostStylingKeeper } from "../../utils/attributes";
+import { referencedElements } from "../../utils/aria-references";
+/**
+ * @slot label - Content displayed as the switch label in place of the `label` text. Clicking it toggles the switch.
+ */
 export class PdsSwitch {
     constructor() {
+        this.inheritedAttributes = {};
+        this._type = 'checkbox';
+        this.forwardsDescription = false;
+        this.hostKeeper = new HostStylingKeeper();
+        this.hasLabelSlot = false;
+        // Kept apart from the `disabled` prop so a fieldset never overwrites what the consumer set.
+        this.fieldsetDisabled = false;
+        /**
+         * Determines the input 'checked' state.
+         */
+        this.checked = false;
+        /**
+         * Determines the input 'disabled' state, preventing user interaction.
+         */
+        this.disabled = false;
+        /**
+         * Determines whether or not the switch is invalid.
+         */
+        this.invalid = false;
+        /**
+         * Determines the 'required' state of the input.
+         */
+        this.required = false;
         this.onSwitchUpdate = (e) => {
-            if (this.disabled)
+            if (this.isDisabled())
                 return;
+            const input = e.target;
+            this.checked = input.checked;
+            this.updateFormValue();
             this.pdsSwitchChange.emit(e);
         };
-        /**
-         * Generate switch classes
-         */
         this.switchClassNames = () => {
             let switchClasses = `pds-switch`;
             if (this.invalid === true) {
@@ -19,35 +47,152 @@ export class PdsSwitch {
             if (this.helperMessage !== undefined) {
                 switchClasses += " pds-switch--message";
             }
+            if (this.hasLabelSlot) {
+                switchClasses += " pds-switch--label-slot";
+            }
             return switchClasses;
         };
-        this.componentId = undefined;
-        this.checked = false;
-        this.disabled = false;
-        this.errorMessage = undefined;
-        this.helperMessage = undefined;
-        this.invalid = false;
-        this.label = undefined;
-        this.name = undefined;
-        this.required = false;
-        this.type = 'checkbox';
-        this.value = undefined;
+        // An ID on the host can't reach into the shadow root, so the input is pointed at the elements the host's
+        // aria-describedby names, followed by its own helper or error message. A browser without ARIA element
+        // reflection keeps the input's own message only.
+        this.forwardDescription = () => {
+            var _a;
+            const input = this.inputEl;
+            if (input === undefined || !('ariaDescribedByElements' in input))
+                return;
+            const ownId = this.ownDescriptionId();
+            const referenced = referencedElements(this.el, 'aria-describedby');
+            if (referenced.length === 0) {
+                if (!this.forwardsDescription)
+                    return;
+                this.forwardsDescription = false;
+                // Setting the element property cleared the attribute render wrote, so put that back.
+                if (ownId !== undefined) {
+                    input.setAttribute('aria-describedby', ownId);
+                }
+                else {
+                    input.removeAttribute('aria-describedby');
+                }
+                return;
+            }
+            const own = ownId === undefined ? null : (_a = this.el.shadowRoot) === null || _a === void 0 ? void 0 : _a.getElementById(ownId);
+            input.ariaDescribedByElements = own == null ? referenced : [...referenced, own];
+            this.forwardsDescription = true;
+        };
+        this.updateHasLabelSlot = () => {
+            this.hasLabelSlot = Array.from(this.el.children).some((child) => child.getAttribute('slot') === 'label');
+        };
+    }
+    isDisabled() {
+        return this.disabled || this.fieldsetDisabled;
+    }
+    connectedCallback() {
+        this.hostKeeper.connect(this.el);
+        // Initialize ElementInternals for form association (only once per element instance)
+        if (this.el.attachInternals && !this.internals) {
+            this.internals = this.el.attachInternals();
+        }
+        // Expose type property on the element instance to match native form element behavior
+        exposeTypeProperty(this.el, () => this._type);
+        // A reconnected switch may sit in a different tree, where its description IDs name other elements.
+        this.forwardDescription();
+        if (typeof MutationObserver === 'undefined')
+            return;
+        // Consumers set aria-describedby on the host, sometimes after render, but only the inner input is announced.
+        this.hostDescriptionObserver = new MutationObserver(this.forwardDescription);
+        this.hostDescriptionObserver.observe(this.el, { attributeFilter: ['aria-describedby'] });
+    }
+    disconnectedCallback() {
+        var _a;
+        this.hostKeeper.disconnect();
+        (_a = this.hostDescriptionObserver) === null || _a === void 0 ? void 0 : _a.disconnect();
+        this.hostDescriptionObserver = undefined;
+    }
+    componentDidRender() {
+        this.forwardDescription();
+    }
+    componentDidLoad() {
+        this.updateFormValue();
+    }
+    syncFormValue() {
+        this.updateFormValue();
+    }
+    updateFormValue() {
+        if (isSpecTest())
+            return;
+        if (this.internals && this.internals.setFormValue) {
+            // The restoration state always carries the checked value, even while disabled, so a bfcache or
+            // back-forward restore can bring back a checked-then-disabled switch instead of losing it to a null state.
+            this.internals.setFormValue(this.formValue(), this.checkedValue());
+        }
+        if (this.internals && this.internals.setValidity) {
+            this.internals.setValidity({});
+        }
+    }
+    // Unchecked sends uncheckedValue when set, even an empty string, otherwise nothing. Disabled sends nothing, like a
+    // native checkbox: the platform only leaves out a host with the disabled attribute present, which is also how
+    // React's own custom-element attribute serialization writes it.
+    formValue() {
+        if (this.isDisabled())
+            return null;
+        return this.checkedValue();
+    }
+    checkedValue() {
+        var _a;
+        if (this.checked)
+            return this.value || 'on';
+        return (_a = this.uncheckedValue) !== null && _a !== void 0 ? _a : null;
+    }
+    ownDescriptionId() {
+        return assignDescription(this.componentId, this.invalid, this.helperMessage, this.errorMessage);
+    }
+    formStateRestoreCallback(state) {
+        if (state instanceof FormData) {
+            // For switches, restore if the value exists in FormData
+            const value = this.value || 'on';
+            this.checked = state.get(this.name || this.componentId) === value;
+        }
+        else if (typeof state === 'string') {
+            // Restore from string state
+            this.checked = state === (this.value || 'on');
+        }
+    }
+    /**
+     * Form Associated Custom Elements API: Called when the form is disabled
+     */
+    formDisabledCallback(disabled) {
+        // Also fires when this element's own `disabled` attribute is merely present, even as the
+        // literal string "false" (a consumer's or React's attribute serialization can write that) —
+        // the platform treats any value as disabled, independent of fieldset state. A real disabled
+        // fieldset ancestor confirms this is genuinely that, not this element's own attribute.
+        this.fieldsetDisabled = disabled && this.el.closest('fieldset[disabled]') !== null;
+    }
+    componentWillLoad() {
+        this.inheritedAttributes = Object.assign({}, inheritAriaAttributes(this.el, ['aria-describedby']));
+        this.updateHasLabelSlot();
     }
     render() {
-        return (h(Host, { key: '5c33e5bd4a42f187450a81faec033832524f1b29', class: this.switchClassNames(), "aria-disabled": this.disabled ? 'true' : null }, h("input", { key: 'cb2a8287cdb44f337b4ecae15968e823f314b4d1', "aria-describedby": assignDescription(this.componentId, this.invalid, this.helperMessage), "aria-invalid": this.invalid ? "true" : undefined, checked: this.checked, class: "pds-switch__input", disabled: this.disabled, id: this.componentId, name: this.name ? this.name : this.componentId, onChange: this.onSwitchUpdate, required: this.required, type: this.type, value: this.value }), h(PdsLabel, { key: '86c700a16a23513b3ba34f2add1775274ecc6784', classNames: "pds-switch__label", htmlFor: this.componentId, text: this.label }), this.helperMessage &&
-            h("div", { key: '30c8b18c990a54330bf3442d9cbbb35387de0ec3', class: `pds-switch__message`, id: messageId(this.componentId, 'helper') }, this.helperMessage), this.errorMessage &&
-            h("div", { key: '1eb57d78271d8c1fbe2fa680eeb88fd2fd1d35c9', class: `pds-switch__message pds-switch__message--error`, id: messageId(this.componentId, 'error'), "aria-live": "assertive" }, this.errorMessage)));
+        const hostClass = this.switchClassNames();
+        const ariaDisabled = this.isDisabled() ? 'true' : null;
+        this.hostKeeper.record(hostClass, {}, { 'aria-disabled': ariaDisabled });
+        return (h(Host, { key: '4c6f12c064caead89979cc4aa0ef25c4581381c3', class: hostClass, "aria-disabled": ariaDisabled }, h("label", { key: 'c97164a6d6318be6cbcc026373e3d5c0a9316d56', htmlFor: this.componentId }, h("input", Object.assign({ key: 'dfaf7408c3fbbed38bd0732ff156e53f57235100', "aria-describedby": this.ownDescriptionId(), "aria-invalid": this.invalid ? "true" : undefined, checked: this.checked, class: "pds-switch__input", disabled: this.isDisabled(), id: this.componentId, name: this.name ? this.name : this.componentId, onChange: this.onSwitchUpdate,
+            // A description added after the switch, or replaced by a framework or a DOM morph, is picked up by the
+            // time focus reaches the switch and it's announced.
+            onFocus: this.forwardDescription, ref: (el) => (this.inputEl = el), required: this.required, type: "checkbox", value: this.value }, this.inheritedAttributes)), h("span", { key: '5e621fa2881bb2d1eddd3dcbc33173f3cf49bd93', class: this.hideLabel ? 'visually-hidden' : '' }, h("slot", { key: 'ef682ce320b8d9f2897676af97e0b4d55c55358a', name: "label", onSlotchange: this.updateHasLabelSlot }), !this.hasLabelSlot && this.label)), this.helperMessage &&
+            h("div", { key: '145da644abc8829de20ca6f9c4532f5341dec441', class: `pds-switch__message`, id: messageId(this.componentId, 'helper') }, this.helperMessage), this.errorMessage &&
+            h("div", { key: '7766e34f6daaf760d78aec6f08b64f0de15deb4c', class: `pds-switch__message pds-switch__message--error`, id: messageId(this.componentId, 'error'), "aria-live": "assertive" }, h("pds-icon", { key: '74dfd91aabf60608e8278ef84119466a2143ffc7', "aria-hidden": "true", icon: danger, size: "small" }), this.errorMessage)));
     }
     static get is() { return "pds-switch"; }
     static get encapsulation() { return "shadow"; }
+    static get formAssociated() { return true; }
     static get originalStyleUrls() {
         return {
-            "$": ["pds-switch.scss"]
+            "$": ["../../global/styles/utils/label.scss", "pds-switch.scss"]
         };
     }
     static get styleUrls() {
         return {
-            "$": ["pds-switch.css"]
+            "$": ["../../global/styles/utils/label.css", "pds-switch.css"]
         };
     }
     static get properties() {
@@ -66,12 +211,14 @@ export class PdsSwitch {
                     "tags": [],
                     "text": "A unique identifier used for the underlying component `id` attribute and the label `for` attribute."
                 },
-                "attribute": "component-id",
-                "reflect": false
+                "getter": false,
+                "setter": false,
+                "reflect": false,
+                "attribute": "component-id"
             },
             "checked": {
                 "type": "boolean",
-                "mutable": false,
+                "mutable": true,
                 "complexType": {
                     "original": "boolean",
                     "resolved": "boolean",
@@ -81,10 +228,12 @@ export class PdsSwitch {
                 "optional": false,
                 "docs": {
                     "tags": [],
-                    "text": "Determines the input 'checked' state"
+                    "text": "Determines the input 'checked' state."
                 },
-                "attribute": "checked",
+                "getter": false,
+                "setter": false,
                 "reflect": false,
+                "attribute": "checked",
                 "defaultValue": "false"
             },
             "disabled": {
@@ -99,10 +248,12 @@ export class PdsSwitch {
                 "optional": true,
                 "docs": {
                     "tags": [],
-                    "text": "Determines the input 'disabled' state, preventing user interaction"
+                    "text": "Determines the input 'disabled' state, preventing user interaction."
                 },
-                "attribute": "disabled",
+                "getter": false,
+                "setter": false,
                 "reflect": false,
+                "attribute": "disabled",
                 "defaultValue": "false"
             },
             "errorMessage": {
@@ -117,10 +268,31 @@ export class PdsSwitch {
                 "optional": true,
                 "docs": {
                     "tags": [],
-                    "text": "Displays message text describing an invalid state"
+                    "text": "Displays an error message below the switch. It becomes the switch's accessible description only while `invalid` is set."
                 },
-                "attribute": "error-message",
-                "reflect": false
+                "getter": false,
+                "setter": false,
+                "reflect": false,
+                "attribute": "error-message"
+            },
+            "hideLabel": {
+                "type": "boolean",
+                "mutable": false,
+                "complexType": {
+                    "original": "boolean",
+                    "resolved": "boolean",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "Visually hides the label text for instances where only the switch should be displayed. Label remains accessible to assistive technology such as screen readers."
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": false,
+                "attribute": "hide-label"
             },
             "helperMessage": {
                 "type": "string",
@@ -134,10 +306,12 @@ export class PdsSwitch {
                 "optional": false,
                 "docs": {
                     "tags": [],
-                    "text": "Displays help text for additional description of an input"
+                    "text": "Displays a message or hint below the switch."
                 },
-                "attribute": "helper-message",
-                "reflect": false
+                "getter": false,
+                "setter": false,
+                "reflect": false,
+                "attribute": "helper-message"
             },
             "invalid": {
                 "type": "boolean",
@@ -151,10 +325,12 @@ export class PdsSwitch {
                 "optional": true,
                 "docs": {
                     "tags": [],
-                    "text": "Determines the input 'invalid' state, signifying an error is present"
+                    "text": "Determines whether or not the switch is invalid."
                 },
-                "attribute": "invalid",
+                "getter": false,
+                "setter": false,
                 "reflect": false,
+                "attribute": "invalid",
                 "defaultValue": "false"
             },
             "label": {
@@ -165,14 +341,16 @@ export class PdsSwitch {
                     "resolved": "string",
                     "references": {}
                 },
-                "required": true,
+                "required": false,
                 "optional": false,
                 "docs": {
                     "tags": [],
-                    "text": "Displays text to describe the input"
+                    "text": "Text to be displayed as the switch label."
                 },
-                "attribute": "label",
-                "reflect": false
+                "getter": false,
+                "setter": false,
+                "reflect": false,
+                "attribute": "label"
             },
             "name": {
                 "type": "string",
@@ -186,10 +364,12 @@ export class PdsSwitch {
                 "optional": false,
                 "docs": {
                     "tags": [],
-                    "text": "Identifies form data and unifies a group of radio inputs for toggling a single property/value"
+                    "text": "Specifies the name. Submitted with the form name/value pair when checked, or with `unchecked-value` while unchecked."
                 },
-                "attribute": "name",
-                "reflect": false
+                "getter": false,
+                "setter": false,
+                "reflect": true,
+                "attribute": "name"
             },
             "required": {
                 "type": "boolean",
@@ -203,34 +383,34 @@ export class PdsSwitch {
                 "optional": true,
                 "docs": {
                     "tags": [],
-                    "text": "Determines the 'required' state of the input"
+                    "text": "Determines the 'required' state of the input."
                 },
-                "attribute": "required",
+                "getter": false,
+                "setter": false,
                 "reflect": false,
+                "attribute": "required",
                 "defaultValue": "false"
             },
-            "type": {
+            "value": {
                 "type": "string",
                 "mutable": false,
                 "complexType": {
-                    "original": "'checkbox' | 'radio'",
-                    "resolved": "\"checkbox\" | \"radio\"",
+                    "original": "string",
+                    "resolved": "string",
                     "references": {}
                 },
                 "required": false,
                 "optional": false,
                 "docs": {
-                    "tags": [{
-                            "name": "defaultValue",
-                            "text": "'checkbox'"
-                        }],
-                    "text": "Specifies the underlying input element type"
+                    "tags": [],
+                    "text": "Provides input with a string submitted in form data."
                 },
-                "attribute": "type",
+                "getter": false,
+                "setter": false,
                 "reflect": false,
-                "defaultValue": "'checkbox'"
+                "attribute": "value"
             },
-            "value": {
+            "uncheckedValue": {
                 "type": "string",
                 "mutable": false,
                 "complexType": {
@@ -239,16 +419,24 @@ export class PdsSwitch {
                     "references": {}
                 },
                 "required": false,
-                "optional": false,
+                "optional": true,
                 "docs": {
                     "tags": [],
-                    "text": "Provides input with a string submitted in form data, and can be used to distinguish radio inputs"
+                    "text": "Provides a string submitted in form data under `name` while the switch is unchecked.\nWhen unset, an unchecked switch submits nothing, like a native checkbox."
                 },
-                "attribute": "value",
-                "reflect": false
+                "getter": false,
+                "setter": false,
+                "reflect": false,
+                "attribute": "unchecked-value"
             }
         };
     }
+    static get states() {
+        return {
+            "hasLabelSlot": {},
+            "fieldsetDisabled": {}
+        };
+    }
     static get events() {
         return [{
                 "method": "pdsSwitchChange",
@@ -258,7 +446,7 @@ export class PdsSwitch {
                 "composed": true,
                 "docs": {
                     "tags": [],
-                    "text": "Emits an event on input change"
+                    "text": "Emitted when the user toggles the switch, by a click or `Space`. `detail` is the native `change` event, so read\nthe new state from the switch's `checked`.\n\nThis event will not emit when programmatically setting the `checked` property."
                 },
                 "complexType": {
                     "original": "InputEvent",
@@ -273,5 +461,22 @@ export class PdsSwitch {
             }];
     }
     static get elementRef() { return "el"; }
+    static get watchers() {
+        return [{
+                "propName": "checked",
+                "methodName": "syncFormValue"
+            }, {
+                "propName": "disabled",
+                "methodName": "syncFormValue"
+            }, {
+                "propName": "fieldsetDisabled",
+                "methodName": "syncFormValue"
+            }, {
+                "propName": "uncheckedValue",
+                "methodName": "syncFormValue"
+            }, {
+                "propName": "value",
+                "methodName": "syncFormValue"
+            }];
+    }
 }
-//# sourceMappingURL=pds-switch.js.map

package/dist/collection/components/pds-switch/stories/pds-switch.stories.js

@@ -1,36 +1,35 @@
 import { html } from 'lit';
-import { extractArgTypes } from '@pxtrn/storybook-addon-docs-stencil';
-import { withActions } from '@storybook/addon-actions/decorator';
+import { ifDefined } from 'lit/directives/if-defined.js';
+
 
 export default {
+
   args: {
     disabled: false,
+    hideLabel: false,
     required: false,
   },
-  argTypes: extractArgTypes('pds-switch'),
   component: 'pds-switch',
-  decorators: [withActions],
-  parameters: {
-    actions: {
-      handles: ['onchange', 'pdsSwitchChange'],
-    },
-  },
+  parameters: {},
   title: 'components/Switch',
 }
 
 const BaseTemplate = (args) => html`
   <pds-switch
-    checked=${args.checked}
+    ?checked=${args.checked}
     component-id=${args.componentId}
-    disabled=${args.disabled}
+    ?disabled=${args.disabled}
     error-message=${args.errorMessage}
     helper-message=${args.helperMessage}
-    invalid=${args.invalid}
+    ?invalid=${args.invalid}
     label=${args.label}
+    ?hide-label=${args.hideLabel}
     name=${args.name}
     onChange=${args.onChange}
-    required=${args.required}
+    ?required=${args.required}
     type=${args.type}
+    unchecked-value=${ifDefined(args.uncheckedValue)}
+    value=${ifDefined(args.value)}
   />
 `;
 
@@ -47,19 +46,6 @@ Default.args = {
   type: 'checkbox',
 };
 
-export const Radio = BaseTemplate.bind({});
-
-Radio.args = {
-  checked: false,
-  disabled: false,
-  componentId: 'pds-switch-radio-example',
-  invalid: false,
-  label: 'radio switch',
-  name: 'pds-switch-radio',
-  required: false,
-  type: 'radio',
-};
-
 export const Disabled = BaseTemplate.bind({});
 
 Disabled.args = {
@@ -73,9 +59,9 @@ Disabled.args = {
   type: 'checkbox',
 };
 
-export const HelperMessage = BaseTemplate.bind({});
+export const WithMessage = BaseTemplate.bind({});
 
-HelperMessage.args = {
+WithMessage.args = {
   checked: true,
   disabled: false,
   componentId: 'pds-switch-helper-example',
@@ -100,3 +86,79 @@ Invalid.args = {
   required: true,
   type: 'checkbox',
 };
+
+export const DisabledWithReason = BaseTemplate.bind({});
+
+DisabledWithReason.args = {
+  checked: false,
+  disabled: true,
+  componentId: 'pds-switch-disabled-reason-example',
+  helperMessage: 'Free offers can\'t have affiliate commissions.',
+  invalid: false,
+  label: 'Affiliate commissions',
+  name: 'pds-switch-disabled-reason',
+  required: false,
+  type: 'checkbox',
+};
+
+export const Described = (args) => html`
+  <pds-box direction="column" gap="xs">
+    <pds-text id="pds-switch-described-text" tag="p">Send customers a receipt after each purchase.</pds-text>
+    <pds-switch
+      aria-describedby="pds-switch-described-text"
+      ?checked=${args.checked}
+      component-id=${args.componentId}
+      ?disabled=${args.disabled}
+      label=${args.label}
+      name=${args.name}
+    ></pds-switch>
+  </pds-box>
+`;
+
+Described.args = {
+  checked: false,
+  disabled: false,
+  componentId: 'pds-switch-described-example',
+  label: 'Purchase receipts',
+  name: 'pds-switch-described',
+};
+
+// Shows what the form submits, since an unchecked value isn't visible on the switch itself.
+const showFormData = (event) => {
+  const form = event.target.closest('form');
+  const output = form?.querySelector('output');
+  if (!form || !output) return;
+  // The switch sets its form value before it emits pdsSwitchChange, so FormData is already current here.
+  const entries = Array.from(new FormData(form).entries());
+  output.textContent = entries.length > 0 ? entries.map(([key, value]) => `${key}=${value}`).join('&') : '(nothing)';
+};
+
+const submitted = ({ checked, name, uncheckedValue, value }) => {
+  if (checked) return `${name}=${value || 'on'}`;
+  return uncheckedValue === undefined ? '(nothing)' : `${name}=${uncheckedValue}`;
+};
+
+export const UncheckedValue = (args) => html`
+  <form @pdsSwitchChange=${showFormData}>
+    <pds-box direction="column" gap="sm">
+      <pds-switch
+        ?checked=${args.checked}
+        component-id=${args.componentId}
+        label=${args.label}
+        name=${args.name}
+        unchecked-value=${ifDefined(args.uncheckedValue)}
+        value=${ifDefined(args.value)}
+      ></pds-switch>
+      <pds-text tag="p">Submits: <output>${submitted(args)}</output></pds-text>
+    </pds-box>
+  </form>
+`;
+
+UncheckedValue.args = {
+  checked: false,
+  componentId: 'pds-switch-unchecked-value-example',
+  label: 'Email notifications',
+  name: 'notify',
+  uncheckedValue: '0',
+  value: '1',
+};

package/dist/collection/components/pds-table/pds-table-body/pds-table-body.js

@@ -1,7 +1,10 @@
 import { Host, h } from "@stencil/core";
+/**
+ * @part body - Set on the `pds-table-body` element itself, so `::part(body)` matches it only from a shadow root that contains it. Style `pds-table-body` directly instead.
+ */
 export class PdsTableBody {
     render() {
-        return (h(Host, { key: '53ae547e27857b0e8e11adcbab634979555b37ab', role: "rowgroup" }, h("slot", { key: 'ba94c5332cdb944a36eecfd8f16c63e1fd0c0c0c' })));
+        return (h(Host, { key: '4b4da65979e3d3557d05cb9aff8d257d29e2c0a5', role: "rowgroup", part: "body" }, h("slot", { key: '70dcd401a705a430c54c57bf994a410a636c4a53' })));
     }
     static get is() { return "pds-table-body"; }
     static get encapsulation() { return "shadow"; }
@@ -16,4 +19,3 @@ export class PdsTableBody {
         };
     }
 }
-//# sourceMappingURL=pds-table-body.js.map