plass-ui 0.0.1 → 1.0.0

package/dist/components/tooltip/PlTooltip.d.ts

@@ -0,0 +1,92 @@
+import * as React from 'react';
+import { Tooltip as BaseUITooltip } from '@base-ui/react/tooltip';
+import type { PlassAlign, PlassSide, PlassStyleProps } from '../../types.js';
+export interface PlTooltipProps extends Pick<PlassStyleProps, 'size' | 'color' | 'density'>, Omit<React.ComponentPropsWithoutRef<'div'>, 'color' | 'content' | 'children'> {
+    /**
+     * What the tooltip says.
+     *
+     * A short phrase. A tooltip is not a container — it cannot be reached by a
+     * pointer on a touch screen, it disappears the moment attention moves, and
+     * anything inside it that could be clicked cannot be. Content that needs
+     * either of those belongs in a sheet that stays put.
+     */
+    content: React.ReactNode;
+    /**
+     * The element the tooltip hangs off. Exactly one element, which must accept a
+     * ref and spread props — every Plass component does.
+     */
+    children: React.ReactElement;
+    /**
+     * Which edge of the trigger it appears on. May flip to the opposite side when
+     * there is no room, which is Base UI's doing and is the right behaviour.
+     * @default 'top'
+     */
+    side?: PlassSide;
+    /**
+     * Where it sits along that edge.
+     * @default 'center'
+     */
+    align?: PlassAlign;
+    /**
+     * Distance from the trigger, in pixels.
+     * @default 6
+     */
+    sideOffset?: number;
+    /**
+     * How long the pointer has to rest before it opens, in milliseconds.
+     * @default 600
+     */
+    delay?: number;
+    /**
+     * How long it waits before closing once the pointer leaves.
+     * @default 0
+     */
+    closeDelay?: number;
+    /**
+     * Draws the little wedge pointing at the trigger.
+     * @default true
+     */
+    arrow?: boolean;
+    /** Whether the tooltip is open. Use with `onOpenChange` for a controlled one. */
+    open?: boolean;
+    /** Whether it starts open, for an uncontrolled one. */
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    /**
+     * Stops the tooltip from opening at all, without disabling the trigger. For
+     * the tooltip that only exists while a label is truncated.
+     * @default false
+     */
+    disabled?: boolean;
+}
+/**
+ * Shares one delay across a group of tooltips: once any of them has opened, its
+ * neighbours open instantly, and the wait comes back after a pause.
+ *
+ * Worth wrapping a toolbar in. Without it, moving along a row of icon buttons
+ * means waiting out the full delay at every stop, which is what makes tooltips
+ * feel like they are fighting the pointer.
+ */
+export declare const PlTooltipProvider: React.FC<import("@base-ui/react").TooltipProviderProps>;
+export type PlTooltipProviderProps = React.ComponentProps<typeof BaseUITooltip.Provider>;
+/**
+ * A short label that appears when the pointer rests on something.
+ *
+ * The whole component is a wrapper:
+ * `<PlTooltip content="Copy"><PlButton …/></PlTooltip>`. Base UI's Trigger
+ * merges itself onto the child rather than rendering a box of its own, so the
+ * tooltip adds no element to the layout and the child stays whatever it was — a
+ * button, a chip, a truncated cell.
+ *
+ * Base UI owns the parts that are genuinely hard: the delay and the group
+ * timeout, opening on focus but not on a focus that came from a click, closing
+ * on Escape, and keeping the popup off the edges of the window.
+ *
+ * The one thing it deliberately leaves open is the part that makes a tooltip
+ * mean anything to a screen reader — `role="tooltip"` on the plate and an
+ * `aria-describedby` pointing at it from the trigger — because a popup can be
+ * many things and only the caller knows which. Here it is always a tooltip, so
+ * this component wires both, and drops the reference while it is closed rather
+ * than pointing at an element that is not in the document.
+ */
+export declare function PlTooltip({ content, children, size, color, density, side, align, sideOffset, delay, closeDelay, arrow, open, defaultOpen, onOpenChange, disabled, className, style, ...props }: PlTooltipProps): React.JSX.Element;

package/dist/components/tooltip/PlTooltip.js

@@ -0,0 +1,117 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import * as React from 'react';
+import { Tooltip as BaseUITooltip } from '@base-ui/react/tooltip';
+import { glassClasses, metaTextClasses, paddingXClasses, radiusClasses, surfaceSlots } from '../../internal/styles.js';
+/**
+ * Shares one delay across a group of tooltips: once any of them has opened, its
+ * neighbours open instantly, and the wait comes back after a pause.
+ *
+ * Worth wrapping a toolbar in. Without it, moving along a row of icon buttons
+ * means waiting out the full delay at every stop, which is what makes tooltips
+ * feel like they are fighting the pointer.
+ */
+export const PlTooltipProvider = BaseUITooltip.Provider;
+/**
+ * The plate, and it is the same floating sheet a `PlSelect`'s popup is: the
+ * glass at its most opaque, a white hairline round it, shadow 3 under it.
+ *
+ * Not a filled key, which is what most libraries draw a tooltip as. A tooltip is
+ * a note *about* something rather than a thing to press, and the library already
+ * has one answer for a surface that floats over arbitrary content — inventing a
+ * second would put two kinds of floating sheet on the same screen.
+ *
+ * `--plass-glass-press` is what makes that safe: at its most opaque the sheet is
+ * dense enough to read a line of text off, which the 62% pane is not.
+ */
+const popupClasses = /* @__PURE__ */ [
+    glassClasses,
+    'max-w-64 border text-(--plass-fg) bg-(--plass-glass-press)',
+    '[border-color:var(--plass-glass-line)]',
+    '[box-shadow:var(--plass-shadow-3),var(--plass-gloss-glass)]',
+    '[outline:none]',
+    // Opacity only, and fast: a tooltip that slides in has moved its own text
+    // while the reader was already looking at it.
+    '[transition:opacity_var(--plass-duration)_var(--plass-ease)]',
+    'data-[starting-style]:opacity-0 data-[ending-style]:opacity-0',
+    // Base UI sets this while the pointer is moving between grouped tooltips.
+    // Fading in a tooltip that is meant to appear instantly is worse than not
+    // fading at all — it reads as lag.
+    'data-[instant]:[transition-duration:0ms]'
+].join(' ');
+/** A row's vertical padding, against the horizontal track `paddingXClasses` sets. */
+const paddingYClasses = {
+    xs: 'py-0.5',
+    sm: 'py-0.5',
+    md: 'py-1',
+    lg: 'py-1.5',
+    xl: 'py-2'
+};
+/** The wedge, at roughly a third of the plate's corner radius per step. */
+const arrowSizes = {
+    xs: 6,
+    sm: 7,
+    md: 8,
+    lg: 9,
+    xl: 10
+};
+/**
+ * A short label that appears when the pointer rests on something.
+ *
+ * The whole component is a wrapper:
+ * `<PlTooltip content="Copy"><PlButton …/></PlTooltip>`. Base UI's Trigger
+ * merges itself onto the child rather than rendering a box of its own, so the
+ * tooltip adds no element to the layout and the child stays whatever it was — a
+ * button, a chip, a truncated cell.
+ *
+ * Base UI owns the parts that are genuinely hard: the delay and the group
+ * timeout, opening on focus but not on a focus that came from a click, closing
+ * on Escape, and keeping the popup off the edges of the window.
+ *
+ * The one thing it deliberately leaves open is the part that makes a tooltip
+ * mean anything to a screen reader — `role="tooltip"` on the plate and an
+ * `aria-describedby` pointing at it from the trigger — because a popup can be
+ * many things and only the caller knows which. Here it is always a tooltip, so
+ * this component wires both, and drops the reference while it is closed rather
+ * than pointing at an element that is not in the document.
+ */
+export function PlTooltip({ content, children, size = 'sm', 
+// A tooltip is a note about something else, never the thing itself, so the
+// neutral family is the honest default. A red tooltip on a delete button would
+// be saying something the tooltip does not know.
+color = 'secondary', density = 'default', side = 'top', align = 'center', sideOffset = 6, delay, closeDelay, arrow = true, open, defaultOpen, onOpenChange, disabled = false, className, style, ...props }) {
+    const arrowSize = arrowSizes[size];
+    const popupId = React.useId();
+    // Mirrored rather than owned: `open` still drives a controlled tooltip and
+    // Base UI still drives an uncontrolled one. This copy exists only so the
+    // trigger knows whether the plate it describes is on the page yet.
+    const [uncontrolledOpen, setUncontrolledOpen] = React.useState(defaultOpen ?? false);
+    const isOpen = open ?? uncontrolledOpen;
+    return (_jsxs(BaseUITooltip.Root, { open: open, defaultOpen: defaultOpen, onOpenChange: (next) => {
+            setUncontrolledOpen(next);
+            onOpenChange?.(next);
+        }, children: [_jsx(BaseUITooltip.Trigger, { render: children, delay: delay, closeDelay: closeDelay, disabled: disabled, "aria-describedby": isOpen ? popupId : undefined }), _jsx(BaseUITooltip.Portal, { children: _jsx(BaseUITooltip.Positioner, { className: "plass-portal z-50 [outline:none]", side: side, align: align, sideOffset: sideOffset, children: _jsxs(BaseUITooltip.Popup, { id: popupId, role: "tooltip", className: [
+                            popupClasses,
+                            radiusClasses[size],
+                            paddingXClasses[density][size],
+                            paddingYClasses[size],
+                            metaTextClasses[size],
+                            className ?? ''
+                        ]
+                            .filter(Boolean)
+                            .join(' '), style: { ...surfaceSlots(color, 3), ...style }, ...props, children: [arrow ? (_jsx(BaseUITooltip.Arrow
+                            // Base UI positions the arrow and reports which side it ended up
+                            // on. The wedge is drawn pointing down and turned to match — a
+                            // rotation of a glyph, which is the same allowance the chevron
+                            // takes. Nothing with text in it moves.
+                            , { 
+                                // Base UI positions the arrow and reports which side it ended up
+                                // on. The wedge is drawn pointing down and turned to match — a
+                                // rotation of a glyph, which is the same allowance the chevron
+                                // takes. Nothing with text in it moves.
+                                className: [
+                                    'data-[side=top]:bottom-[-1px]',
+                                    'data-[side=bottom]:top-[-1px] data-[side=bottom]:rotate-180',
+                                    'data-[side=left]:right-[-1px] data-[side=left]:-rotate-90',
+                                    'data-[side=right]:left-[-1px] data-[side=right]:rotate-90'
+                                ].join(' '), children: _jsxs("svg", { width: arrowSize, height: arrowSize / 2, viewBox: "0 0 10 5", "aria-hidden": "true", className: "block", children: [_jsx("path", { d: "M0 0h10L5 5z", fill: "var(--plass-glass-line)" }), _jsx("path", { d: "M0 0h10L5 5z", fill: "var(--plass-glass-press)", transform: "translate(0 -1)" })] }) })) : null, content] }) }) })] }));
+}

package/dist/components/tooltip/index.d.ts

@@ -0,0 +1,2 @@
+export { PlTooltip, PlTooltipProvider } from './PlTooltip.js';
+export type { PlTooltipProps, PlTooltipProviderProps } from './PlTooltip.js';

package/dist/components/tooltip/index.js

@@ -0,0 +1 @@
+export { PlTooltip, PlTooltipProvider } from './PlTooltip.js';

package/dist/components/typography/PlTypography.d.ts

@@ -0,0 +1,66 @@
+import * as React from 'react';
+import { useRender } from '@base-ui/react/use-render';
+import type { PlassColor } from '../../types.js';
+/**
+ * What a piece of text *is*, which decides both its type scale and the element
+ * it renders as.
+ *
+ * This is deliberately not called `variant`. In this library `variant` names
+ * what a surface is made of — `solid` / `glass` / `ghost` — and a second meaning
+ * for the same word is exactly what the prop conventions forbid.
+ */
+export type PlTypographyLevel = 'h1' | 'h2' | 'h3' | 'h4' | 'h5' | 'h6' | 'body' | 'lead' | 'caption' | 'overline';
+export type PlTypographyAlign = 'start' | 'center' | 'end' | 'justify';
+export type PlTypographyWeight = 'regular' | 'medium' | 'semibold' | 'bold';
+export interface PlTypographyProps extends Omit<React.ComponentPropsWithoutRef<'p'>, 'color' | 'children'> {
+    /**
+     * The type scale, and the element that carries it. `h1`–`h6` render the
+     * matching heading, `lead`/`body` a `<p>`, `caption`/`overline` a `<span>`.
+     * @default 'body'
+     */
+    level?: PlTypographyLevel;
+    /**
+     * Semantic colour role. Unlike every other component this has **no default**:
+     * text inherits the page's own colour unless a role is asked for, because the
+     * common case for a paragraph is to look like the paragraphs around it.
+     */
+    color?: PlassColor;
+    /** Overrides the weight the level would otherwise pick. */
+    weight?: PlTypographyWeight;
+    align?: PlTypographyAlign;
+    /**
+     * Clamps the text to this many lines with an ellipsis. `1` is a single-line
+     * truncation. Omit it and the text wraps as far as it needs to.
+     */
+    lines?: number;
+    /**
+     * Adds the space below that a run of prose expects. Off by default: a library
+     * component that injects margins is one a layout has to fight.
+     * @default false
+     */
+    gutter?: boolean;
+    /**
+     * Renders a different element without changing the type scale — an `h2`-sized
+     * line that is semantically a `<p>`, or the other way round. Base UI's own
+     * escape hatch.
+     */
+    render?: useRender.RenderProp;
+    children?: React.ReactNode;
+}
+/**
+ * Text at one of the library's sizes.
+ *
+ * The type scale is the one thing in a design system that everything else is
+ * measured against, and until now it only existed inside the components that
+ * happened to need it — a card's title, a field's label. This is that ladder on
+ * its own, so a page can use it without wrapping its prose in a card.
+ *
+ * `level` sets the scale *and* the element, which is the common case. When they
+ * have to differ — a subheading that should not enter the document outline, a
+ * `<p>` that has to look like an `h3` — `render` breaks the tie.
+ *
+ * There is no `variant` and no `elevation`, and there is no `size` either.
+ * `level` is the size: a `size` prop alongside it would let a caller ask for an
+ * `h1` at `xs`, which is a heading that is not a heading.
+ */
+export declare const PlTypography: React.ForwardRefExoticComponent<PlTypographyProps & React.RefAttributes<HTMLElement>>;

package/dist/components/typography/PlTypography.js

@@ -0,0 +1,143 @@
+import * as React from 'react';
+import { useRender } from '@base-ui/react/use-render';
+/**
+ * The scale.
+ *
+ * Body sits on the sheet body ladder at `md` (13px/22px), so a paragraph inside
+ * a `PlCard` and a standalone one are the same text. The headings step up from
+ * there by roughly a major third, and the leading tightens as they grow — a 30px
+ * line does not want the same 1.7 ratio a 13px one does.
+ */
+const levelClasses = {
+    h1: 'text-[1.875rem]/[2.25rem] tracking-[-0.02em]',
+    h2: 'text-[1.5rem]/[1.875rem] tracking-[-0.015em]',
+    h3: 'text-[1.25rem]/[1.625rem] tracking-[-0.01em]',
+    h4: 'text-[1.0625rem]/[1.5rem]',
+    h5: 'text-[0.9375rem]/[1.375rem]',
+    h6: 'text-[0.8125rem]/[1.25rem]',
+    lead: 'text-[1.0625rem]/[1.75rem]',
+    body: 'text-[0.8125rem]/[1.375rem]',
+    caption: 'text-[0.75rem]/[1.125rem]',
+    overline: 'text-[0.6875rem]/[1rem] tracking-[0.08em] uppercase'
+};
+/**
+ * Weight is kept out of `levelClasses` and resolved here so that exactly one
+ * `font-*` class is ever emitted. Passing both the level's weight and an
+ * override would leave two utilities of equal specificity on the element, and
+ * which of them wins is decided by their order in the generated stylesheet —
+ * `font-semibold` beats `font-normal` there no matter which one was asked for.
+ */
+const levelWeights = {
+    h1: 'semibold',
+    h2: 'semibold',
+    h3: 'semibold',
+    h4: 'semibold',
+    h5: 'semibold',
+    h6: 'semibold',
+    lead: 'regular',
+    body: 'regular',
+    caption: 'regular',
+    overline: 'medium'
+};
+/** The element each level renders as when `render` is not given. */
+const levelElements = {
+    h1: 'h1',
+    h2: 'h2',
+    h3: 'h3',
+    h4: 'h4',
+    h5: 'h5',
+    h6: 'h6',
+    lead: 'p',
+    body: 'p',
+    caption: 'span',
+    overline: 'span'
+};
+/**
+ * The two quiet levels are muted by default. Everything else takes the page's
+ * own foreground — a heading that arrived pre-greyed is a heading a designer has
+ * to undo.
+ */
+const mutedLevels = new Set(['caption', 'overline']);
+/** How much room a level leaves under itself when `gutter` is on. */
+const gutterClasses = {
+    h1: 'mb-4',
+    h2: 'mb-3.5',
+    h3: 'mb-3',
+    h4: 'mb-2.5',
+    h5: 'mb-2',
+    h6: 'mb-2',
+    lead: 'mb-4',
+    body: 'mb-3',
+    caption: 'mb-2',
+    overline: 'mb-2'
+};
+const weightClasses = {
+    regular: 'font-normal',
+    medium: 'font-medium',
+    semibold: 'font-semibold',
+    bold: 'font-bold'
+};
+const alignClasses = {
+    start: 'text-start',
+    center: 'text-center',
+    end: 'text-end',
+    justify: 'text-justify'
+};
+/**
+ * Clamping is two different mechanisms. One line is `text-overflow: ellipsis`,
+ * which keeps the text on its own baseline; more than one needs the line-clamp
+ * box, which only ellipsises because WebKit says so.
+ */
+const clampClasses = {
+    1: 'truncate',
+    2: 'line-clamp-2',
+    3: 'line-clamp-3',
+    4: 'line-clamp-4',
+    5: 'line-clamp-5',
+    6: 'line-clamp-6'
+};
+/**
+ * Text at one of the library's sizes.
+ *
+ * The type scale is the one thing in a design system that everything else is
+ * measured against, and until now it only existed inside the components that
+ * happened to need it — a card's title, a field's label. This is that ladder on
+ * its own, so a page can use it without wrapping its prose in a card.
+ *
+ * `level` sets the scale *and* the element, which is the common case. When they
+ * have to differ — a subheading that should not enter the document outline, a
+ * `<p>` that has to look like an `h3` — `render` breaks the tie.
+ *
+ * There is no `variant` and no `elevation`, and there is no `size` either.
+ * `level` is the size: a `size` prop alongside it would let a caller ask for an
+ * `h1` at `xs`, which is a heading that is not a heading.
+ */
+export const PlTypography = /* @__PURE__ */ React.forwardRef(function PlTypography({ level = 'body', color, weight, align, lines, gutter = false, render, className, style, children, ...props }, ref) {
+    const classNames = [
+        levelClasses[level],
+        weightClasses[weight ?? levelWeights[level]],
+        align ? alignClasses[align] : '',
+        lines ? (clampClasses[lines] ?? 'line-clamp-6') : '',
+        gutter ? gutterClasses[level] : '',
+        color
+            ? 'text-(--p-accent)'
+            : mutedLevels.has(level)
+                ? 'text-(--plass-muted-fg)'
+                : 'text-(--plass-fg)',
+        className ?? ''
+    ]
+        .filter(Boolean)
+        .join(' ');
+    return useRender({
+        render: render ?? React.createElement(levelElements[level]),
+        ref,
+        props: {
+            className: classNames,
+            style: (color
+                ? { '--p-accent': `var(--plass-${color}-accent)`, ...style }
+                : style),
+            children,
+            ...props
+        }
+    });
+});

package/dist/components/typography/index.d.ts

@@ -0,0 +1,2 @@
+export { PlTypography } from './PlTypography.js';
+export type { PlTypographyAlign, PlTypographyLevel, PlTypographyProps, PlTypographyWeight } from './PlTypography.js';

package/dist/components/typography/index.js

@@ -0,0 +1 @@
+export { PlTypography } from './PlTypography.js';

package/dist/css/accordion.css

@@ -0,0 +1,2 @@
+/* Scan manifest for <accordion>. Needs `plass-ui/css/base.css` first. */
+@source '../components/accordion';

package/dist/css/alert.css

@@ -0,0 +1,2 @@
+/* Scan manifest for <alert>. Needs `plass-ui/css/base.css` first. */
+@source '../components/alert';

package/dist/css/animate-appear.css

@@ -0,0 +1,2 @@
+/* Scan manifest for <animate-appear>. Needs `plass-ui/css/base.css` first. */
+@source '../components/animate-appear';

package/dist/css/animate-blink.css

@@ -0,0 +1,2 @@
+/* Scan manifest for <animate-blink>. Needs `plass-ui/css/base.css` first. */
+@source '../components/animate-blink';

package/dist/css/animate-fade.css

@@ -0,0 +1,2 @@
+/* Scan manifest for <animate-fade>. Needs `plass-ui/css/base.css` first. */
+@source '../components/animate-fade';

package/dist/css/animate-grow.css

@@ -0,0 +1,2 @@
+/* Scan manifest for <animate-grow>. Needs `plass-ui/css/base.css` first. */
+@source '../components/animate-grow';

package/dist/css/animate-headline.css

@@ -0,0 +1,2 @@
+/* Scan manifest for <animate-headline>. Needs `plass-ui/css/base.css` first. */
+@source '../components/animate-headline';

package/dist/css/animate-lighting.css

@@ -0,0 +1,2 @@
+/* Scan manifest for <animate-lighting>. Needs `plass-ui/css/base.css` first. */
+@source '../components/animate-lighting';

package/dist/css/animate-marquee.css

@@ -0,0 +1,2 @@
+/* Scan manifest for <animate-marquee>. Needs `plass-ui/css/base.css` first. */
+@source '../components/animate-marquee';

package/dist/css/animate-rotate.css

@@ -0,0 +1,2 @@
+/* Scan manifest for <animate-rotate>. Needs `plass-ui/css/base.css` first. */
+@source '../components/animate-rotate';

package/dist/css/animate-slide.css

@@ -0,0 +1,2 @@
+/* Scan manifest for <animate-slide>. Needs `plass-ui/css/base.css` first. */
+@source '../components/animate-slide';

package/dist/css/animate-typing.css

@@ -0,0 +1,2 @@
+/* Scan manifest for <animate-typing>. Needs `plass-ui/css/base.css` first. */
+@source '../components/animate-typing';

package/dist/css/animate-zoom.css

@@ -0,0 +1,2 @@
+/* Scan manifest for <animate-zoom>. Needs `plass-ui/css/base.css` first. */
+@source '../components/animate-zoom';

package/dist/css/aspect-ratio.css

@@ -0,0 +1,2 @@
+/* Scan manifest for <aspect-ratio>. Needs `plass-ui/css/base.css` first. */
+@source '../components/aspect-ratio';

package/dist/css/avatar.css

@@ -0,0 +1,2 @@
+/* Scan manifest for <avatar>. Needs `plass-ui/css/base.css` first. */
+@source '../components/avatar';

package/dist/css/badge.css

@@ -0,0 +1,2 @@
+/* Scan manifest for <badge>. Needs `plass-ui/css/base.css` first. */
+@source '../components/badge';

package/dist/css/base.css

@@ -0,0 +1,4 @@
+/* The tokens, plus the classes every component shares.
+ * Import this once, then one `plass-ui/css/<component>.css` per component. */
+@import '../tokens.css';
+@source '../internal';

package/dist/css/blockquote.css

@@ -0,0 +1,2 @@
+/* Scan manifest for <blockquote>. Needs `plass-ui/css/base.css` first. */
+@source '../components/blockquote';

package/dist/css/bottom-navigation.css

@@ -0,0 +1,2 @@
+/* Scan manifest for <bottom-navigation>. Needs `plass-ui/css/base.css` first. */
+@source '../components/bottom-navigation';

package/dist/css/box.css

@@ -0,0 +1,2 @@
+/* Scan manifest for <box>. Needs `plass-ui/css/base.css` first. */
+@source '../components/box';

package/dist/css/breadcrumb.css

@@ -0,0 +1,2 @@
+/* Scan manifest for <breadcrumb>. Needs `plass-ui/css/base.css` first. */
+@source '../components/breadcrumb';

package/dist/css/button-group.css

@@ -0,0 +1,2 @@
+/* Scan manifest for <button-group>. Needs `plass-ui/css/base.css` first. */
+@source '../components/button-group';

package/dist/css/button.css

@@ -0,0 +1,2 @@
+/* Scan manifest for <button>. Needs `plass-ui/css/base.css` first. */
+@source '../components/button';

package/dist/css/card.css

@@ -0,0 +1,2 @@
+/* Scan manifest for <card>. Needs `plass-ui/css/base.css` first. */
+@source '../components/card';

package/dist/css/carousel.css

@@ -0,0 +1,2 @@
+/* Scan manifest for <carousel>. Needs `plass-ui/css/base.css` first. */
+@source '../components/carousel';

package/dist/css/chat-bubble.css

@@ -0,0 +1,2 @@
+/* Scan manifest for <chat-bubble>. Needs `plass-ui/css/base.css` first. */
+@source '../components/chat-bubble';

package/dist/css/checkbox.css

@@ -0,0 +1,2 @@
+/* Scan manifest for <checkbox>. Needs `plass-ui/css/base.css` first. */
+@source '../components/checkbox';

package/dist/css/chip.css

@@ -0,0 +1,2 @@
+/* Scan manifest for <chip>. Needs `plass-ui/css/base.css` first. */
+@source '../components/chip';

package/dist/css/collapsible.css

@@ -0,0 +1,2 @@
+/* Scan manifest for <collapsible>. Needs `plass-ui/css/base.css` first. */
+@source '../components/collapsible';

package/dist/css/combobox.css

@@ -0,0 +1,2 @@
+/* Scan manifest for <combobox>. Needs `plass-ui/css/base.css` first. */
+@source '../components/combobox';

package/dist/css/container.css

@@ -0,0 +1,2 @@
+/* Scan manifest for <container>. Needs `plass-ui/css/base.css` first. */
+@source '../components/container';

package/dist/css/date-picker.css

@@ -0,0 +1,2 @@
+/* Scan manifest for <date-picker>. Needs `plass-ui/css/base.css` first. */
+@source '../components/date-picker';

package/dist/css/date-range-picker.css

@@ -0,0 +1,2 @@
+/* Scan manifest for <date-range-picker>. Needs `plass-ui/css/base.css` first. */
+@source '../components/date-range-picker';

package/dist/css/date-time-picker.css

@@ -0,0 +1,2 @@
+/* Scan manifest for <date-time-picker>. Needs `plass-ui/css/base.css` first. */
+@source '../components/date-time-picker';

package/dist/css/divider.css

@@ -0,0 +1,2 @@
+/* Scan manifest for <divider>. Needs `plass-ui/css/base.css` first. */
+@source '../components/divider';

package/dist/css/drawer.css

@@ -0,0 +1,2 @@
+/* Scan manifest for <drawer>. Needs `plass-ui/css/base.css` first. */
+@source '../components/drawer';

package/dist/css/file-picker.css

@@ -0,0 +1,2 @@
+/* Scan manifest for <file-picker>. Needs `plass-ui/css/base.css` first. */
+@source '../components/file-picker';

package/dist/css/floating-bottom-navigation.css

@@ -0,0 +1,2 @@
+/* Scan manifest for <floating-bottom-navigation>. Needs `plass-ui/css/base.css` first. */
+@source '../components/floating-bottom-navigation';

package/dist/css/grid.css

@@ -0,0 +1,2 @@
+/* Scan manifest for <grid>. Needs `plass-ui/css/base.css` first. */
+@source '../components/grid';

package/dist/css/highlight.css

@@ -0,0 +1,2 @@
+/* Scan manifest for <highlight>. Needs `plass-ui/css/base.css` first. */
+@source '../components/highlight';

package/dist/css/hot-keys.css

@@ -0,0 +1,2 @@
+/* Scan manifest for <hot-keys>. Needs `plass-ui/css/base.css` first. */
+@source '../components/hot-keys';

package/dist/css/icon-button.css

@@ -0,0 +1,2 @@
+/* Scan manifest for <icon-button>. Needs `plass-ui/css/base.css` first. */
+@source '../components/icon-button';

package/dist/css/icon.css

@@ -0,0 +1,2 @@
+/* Scan manifest for <icon>. Needs `plass-ui/css/base.css` first. */
+@source '../components/icon';

package/dist/css/list.css

@@ -0,0 +1,2 @@
+/* Scan manifest for <list>. Needs `plass-ui/css/base.css` first. */
+@source '../components/list';

package/dist/css/menu.css

@@ -0,0 +1,2 @@
+/* Scan manifest for <menu>. Needs `plass-ui/css/base.css` first. */
+@source '../components/menu';

package/dist/css/modal.css

@@ -0,0 +1,2 @@
+/* Scan manifest for <modal>. Needs `plass-ui/css/base.css` first. */
+@source '../components/modal';