@ark-ui/solid 1.3.0 → 2.0.0

package/types/tooltip/index.d.ts

@@ -1,18 +1,18 @@
 import type { OpenChangeDetails as TooltipOpenChangeDetails } from '@zag-js/tooltip';
-import { type TooltipProps } from './tooltip';
 import { TooltipArrow, type TooltipArrowProps } from './tooltip-arrow';
 import { TooltipArrowTip, type TooltipArrowTipProps } from './tooltip-arrow-tip';
 import { TooltipContent, type TooltipContentProps } from './tooltip-content';
 import { useTooltipContext, type TooltipContext } from './tooltip-context';
 import { TooltipPositioner, type TooltipPositionerProps } from './tooltip-positioner';
+import { TooltipRoot, type TooltipRootProps } from './tooltip-root';
 import { TooltipTrigger, type TooltipTriggerProps } from './tooltip-trigger';
-declare const Tooltip: ((props: TooltipProps) => import("solid-js").JSX.Element) & {
-    Root: (props: TooltipProps) => import("solid-js").JSX.Element;
-    Arrow: (props: TooltipArrowProps) => import("solid-js").JSX.Element;
-    ArrowTip: (props: TooltipArrowTipProps) => import("solid-js").JSX.Element;
-    Content: (props: TooltipContentProps) => import("solid-js").JSX.Element;
-    Positioner: (props: TooltipPositionerProps) => import("solid-js").JSX.Element;
-    Trigger: (props: TooltipTriggerProps) => import("solid-js").JSX.Element;
+export declare const Tooltip: {
+    Root: (props: TooltipRootProps) => import("solid-js").JSX.Element;
+    Arrow: import("..").ArkComponent<"div", object>;
+    ArrowTip: import("..").ArkComponent<"div", object>;
+    Content: import("..").ArkComponent<"div", object>;
+    Positioner: import("..").ArkComponent<"div", object>;
+    Trigger: import("..").ArkComponent<"button", object>;
 };
-export { Tooltip, TooltipArrow, TooltipArrowTip, TooltipContent, TooltipPositioner, TooltipTrigger, useTooltipContext, };
-export type { TooltipArrowProps, TooltipArrowTipProps, TooltipContentProps, TooltipContext, TooltipOpenChangeDetails, TooltipPositionerProps, TooltipProps, TooltipTriggerProps, };
+export { TooltipArrow, TooltipArrowTip, TooltipContent, TooltipPositioner, TooltipRoot, TooltipTrigger, useTooltipContext, };
+export type { TooltipArrowProps, TooltipArrowTipProps, TooltipContentProps, TooltipContext, TooltipOpenChangeDetails, TooltipPositionerProps, TooltipRootProps, TooltipTriggerProps, };

package/types/tooltip/tooltip-arrow-tip.d.ts

@@ -1,4 +1,4 @@
-import { type HTMLArkProps } from '../factory';
+import { type ArkComponent, type HTMLArkProps } from '../factory';
 export interface TooltipArrowTipProps extends HTMLArkProps<'div'> {
 }
-export declare const TooltipArrowTip: (props: TooltipArrowTipProps) => import("solid-js").JSX.Element;
+export declare const TooltipArrowTip: ArkComponent<'div'>;

package/types/tooltip/tooltip-arrow.d.ts

@@ -1,4 +1,4 @@
-import { type HTMLArkProps } from '../factory';
+import { type ArkComponent, type HTMLArkProps } from '../factory';
 export interface TooltipArrowProps extends HTMLArkProps<'div'> {
 }
-export declare const TooltipArrow: (props: TooltipArrowProps) => import("solid-js").JSX.Element;
+export declare const TooltipArrow: ArkComponent<'div'>;

package/types/tooltip/tooltip-content.d.ts

@@ -1,4 +1,4 @@
-import { type HTMLArkProps } from '../factory';
+import { type ArkComponent, type HTMLArkProps } from '../factory';
 export interface TooltipContentProps extends HTMLArkProps<'div'> {
 }
-export declare const TooltipContent: (props: TooltipContentProps) => import("solid-js").JSX.Element;
+export declare const TooltipContent: ArkComponent<'div'>;

package/types/tooltip/tooltip-positioner.d.ts

@@ -1,4 +1,4 @@
-import { type HTMLArkProps } from '../factory';
+import { type ArkComponent, type HTMLArkProps } from '../factory';
 export interface TooltipPositionerProps extends HTMLArkProps<'div'> {
 }
-export declare const TooltipPositioner: (props: TooltipPositionerProps) => import("solid-js").JSX.Element;
+export declare const TooltipPositioner: ArkComponent<'div'>;

package/types/tooltip/{tooltip.d.ts → tooltip-root.d.ts}

@@ -1,7 +1,7 @@
 import { type JSX } from 'solid-js';
 import { type UsePresenceProps } from '../presence';
 import { type UseTooltipProps, type UseTooltipReturn } from './use-tooltip';
-export interface TooltipProps extends UseTooltipProps, UsePresenceProps {
+export interface TooltipRootProps extends UseTooltipProps, UsePresenceProps {
     children?: JSX.Element | ((api: UseTooltipReturn) => JSX.Element);
 }
-export declare const Tooltip: (props: TooltipProps) => JSX.Element;
+export declare const TooltipRoot: (props: TooltipRootProps) => JSX.Element;

package/types/tooltip/tooltip-trigger.d.ts

@@ -1,4 +1,4 @@
-import { type HTMLArkProps } from '../factory';
+import { type ArkComponent, type HTMLArkProps } from '../factory';
 export interface TooltipTriggerProps extends HTMLArkProps<'button'> {
 }
-export declare const TooltipTrigger: (props: TooltipTriggerProps) => import("solid-js").JSX.Element;
+export declare const TooltipTrigger: ArkComponent<'button'>;

package/types/tree-view/tree-view-branch-content.d.ts

@@ -0,0 +1,6 @@
+import { type ArkComponent, type HTMLArkProps } from '../factory';
+import type { Assign } from '../types';
+import { type BranchProps } from './tree-view-context';
+export interface TreeViewBranchContentProps extends Assign<HTMLArkProps<'ul'>, BranchProps> {
+}
+export declare const TreeViewBranchContent: ArkComponent<'ul', BranchProps>;

package/types/tree-view/tree-view-branch-control.d.ts

@@ -0,0 +1,6 @@
+import { type ArkComponent, type HTMLArkProps } from '../factory';
+import type { Assign } from '../types';
+import { type BranchProps } from './tree-view-context';
+export interface TreeViewBranchControlProps extends Assign<HTMLArkProps<'div'>, BranchProps> {
+}
+export declare const TreeViewBranchControl: ArkComponent<'div', BranchProps>;

package/types/tree-view/tree-view-branch-indicator.d.ts

@@ -0,0 +1,6 @@
+import { type ArkComponent, type HTMLArkProps } from '../factory';
+import type { Assign } from '../types';
+import { type BranchProps } from './tree-view-context';
+export interface TreeViewBranchIndicatorProps extends Assign<HTMLArkProps<'div'>, BranchProps> {
+}
+export declare const TreeViewBranchIndicator: ArkComponent<'div', BranchProps>;

package/types/tree-view/tree-view-branch-text.d.ts

@@ -0,0 +1,6 @@
+import { type ArkComponent, type HTMLArkProps } from '../factory';
+import type { Assign } from '../types';
+import { type BranchProps } from './tree-view-context';
+export interface TreeViewBranchTextProps extends Assign<HTMLArkProps<'span'>, BranchProps> {
+}
+export declare const TreeViewBranchText: ArkComponent<'span', BranchProps>;

package/types/tree-view/tree-view-branch-trigger.d.ts

@@ -0,0 +1,6 @@
+import { type ArkComponent, type HTMLArkProps } from '../factory';
+import type { Assign } from '../types';
+import { type BranchProps } from './tree-view-context';
+export interface TreeViewBranchTriggerProps extends Assign<HTMLArkProps<'button'>, BranchProps> {
+}
+export declare const TreeViewBranchTrigger: ArkComponent<'button', BranchProps>;

package/types/tree-view/tree-view-branch.d.ts

@@ -0,0 +1,11 @@
+import { type Accessor, type JSX } from 'solid-js';
+import { type ArkComponent, type HTMLArkProps } from '../factory';
+import type { Assign } from '../types';
+import { type BranchProps, type BranchState } from './tree-view-context';
+interface ElementProps extends BranchProps {
+    children?: JSX.Element | ((state: Accessor<BranchState>) => JSX.Element);
+}
+export interface TreeViewBranchProps extends Assign<HTMLArkProps<'li'>, ElementProps> {
+}
+export declare const TreeViewBranch: ArkComponent<'li', ElementProps>;
+export {};

package/types/tree-view/tree-view-context.d.ts

@@ -0,0 +1,20 @@
+import { type UseTreeViewReturn } from './use-tree-view';
+export interface ItemProps {
+    depth: number;
+    id: string;
+    disabled?: boolean;
+}
+export interface BranchProps extends ItemProps {
+}
+export interface ItemState {
+    id: string;
+    isDisabled: boolean;
+    isSelected: boolean;
+    isFocused: boolean;
+}
+export interface BranchState extends ItemState {
+    isExpanded: boolean;
+}
+export interface TreeViewContext extends UseTreeViewReturn {
+}
+export declare const TreeViewProvider: import("solid-js").ContextProviderComponent<TreeViewContext>, useTreeViewContext: () => TreeViewContext;

package/types/tree-view/tree-view-item-text.d.ts

@@ -0,0 +1,6 @@
+import { type ArkComponent, type HTMLArkProps } from '../factory';
+import type { Assign } from '../types';
+import { type ItemProps } from './tree-view-context';
+export interface TreeViewItemTextProps extends Assign<HTMLArkProps<'span'>, ItemProps> {
+}
+export declare const TreeViewItemText: ArkComponent<'span', ItemProps>;

package/types/tree-view/tree-view-item.d.ts

@@ -0,0 +1,11 @@
+import { type Accessor, type JSX } from 'solid-js';
+import { type ArkComponent, type HTMLArkProps } from '../factory';
+import type { Assign } from '../types';
+import { type ItemProps, type ItemState } from './tree-view-context';
+interface ElementProps extends ItemProps {
+    children?: JSX.Element | ((state: Accessor<ItemState>) => JSX.Element);
+}
+export interface TreeViewItemProps extends Assign<HTMLArkProps<'li'>, ElementProps> {
+}
+export declare const TreeViewItem: ArkComponent<'li', ElementProps>;
+export {};

package/types/tree-view/tree-view-label.d.ts

@@ -0,0 +1,4 @@
+import { type ArkComponent, type HTMLArkProps } from '../factory';
+export interface TreeViewLabelProps extends HTMLArkProps<'label'> {
+}
+export declare const TreeViewLabel: ArkComponent<'label'>;

package/types/tree-view/tree-view-root.d.ts

@@ -0,0 +1,11 @@
+import { type JSX } from 'solid-js';
+import { type ArkComponent, type HTMLArkProps } from '../factory';
+import type { Assign } from '../types';
+import { type UseTreeViewProps, type UseTreeViewReturn } from './use-tree-view';
+interface ElementProps extends UseTreeViewProps {
+    children?: JSX.Element | ((api: UseTreeViewReturn) => JSX.Element);
+}
+export interface TreeViewRootProps extends Assign<HTMLArkProps<'div'>, ElementProps> {
+}
+export declare const TreeViewRoot: ArkComponent<'div', ElementProps>;
+export {};

package/types/tree-view/tree-view-tree.d.ts

@@ -0,0 +1,4 @@
+import { type ArkComponent, type HTMLArkProps } from '../factory';
+export interface TreeViewTreeProps extends HTMLArkProps<'ul'> {
+}
+export declare const TreeViewTree: ArkComponent<'ul'>;

package/types/tree-view/use-tree-view.d.ts

@@ -0,0 +1,9 @@
+import { type PropTypes } from '@zag-js/solid';
+import * as treeView from '@zag-js/tree-view';
+import { type Accessor } from 'solid-js';
+import { type Optional } from '../types';
+export interface UseTreeViewProps extends Optional<treeView.Context, 'id'> {
+}
+export interface UseTreeViewReturn extends Accessor<treeView.Api<PropTypes>> {
+}
+export declare const useTreeView: (props: UseTreeViewProps) => UseTreeViewReturn;

package/source/constants.js

@@ -1,27 +0,0 @@
-const booleans = [
-    'allowfullscreen',
-    'async',
-    'autofocus',
-    'autoplay',
-    'checked',
-    'controls',
-    'default',
-    'disabled',
-    'formnovalidate',
-    'hidden',
-    'indeterminate',
-    'ismap',
-    'loop',
-    'multiple',
-    'muted',
-    'nomodule',
-    'novalidate',
-    'open',
-    'playsinline',
-    'readonly',
-    'required',
-    'reversed',
-    'seamless',
-    'selected',
-];
-export const BooleanAttributes = new Set(booleans);

package/source/filter-object.js

@@ -1,7 +0,0 @@
-import { BooleanAttributes } from './constants';
-import { isEmpty } from './is-empty';
-import { isFunction } from './is-function';
-export const filterObject = (obj, fn) => Object.fromEntries(Object.entries(obj).filter(fn));
-export const filterEmptyValues = (obj) => filterObject(obj, ([, v]) => !isEmpty(v));
-export const filterFunctionValues = (obj) => filterObject(obj, ([, v]) => !isFunction(v));
-export const filterBooleanAttributeValues = (obj) => filterObject(obj, ([k, v]) => !(BooleanAttributes.has(k) && !v));

package/source/is-empty.js

@@ -1,4 +0,0 @@
-export const isEmpty = (value) => value == null ||
-    value == undefined ||
-    (typeof value === 'object' && Object.keys(value).length === 0) ||
-    (typeof value === 'string' && value.trim().length === 0);

package/source/is-function.js

@@ -1 +0,0 @@
-export const isFunction = (value) => typeof value === 'function';

package/source/merge-style.js

@@ -1,30 +0,0 @@
-export const mergeStyle = (a, b) => styleObjectToString({ ...getStyleObject(a), ...getStyleObject(b) });
-const getStyleObject = (style) => typeof style === 'object' ? style : stringStyleToObject(style);
-const stringStyleToObject = (style) => {
-    const object = {};
-    if (!style)
-        return object;
-    const extractCSSregex = /([^:; ]*):\s*([^;]*)/g;
-    let match;
-    while ((match = extractCSSregex.exec(style))) {
-        object[match[1]] = match[2];
-    }
-    return object;
-};
-const styleObjectToString = (value) => {
-    if (!value)
-        return '';
-    let result = '';
-    const k = Object.keys(value);
-    for (let i = 0; i < k.length; i++) {
-        const s = k[i];
-        // @ts-expect-error - we know this is a string
-        const v = value[s];
-        if (v != undefined) {
-            if (i)
-                result += ';';
-            result += `${s}:${v}`;
-        }
-    }
-    return result;
-};

package/source/parse-template.js

@@ -1,248 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-// Forked from https://github.com/natemoo-re/ultrahtml.git under MIT license
-const DOCUMENT_NODE = 0;
-const ELEMENT_NODE = 1;
-const TEXT_NODE = 2;
-const COMMENT_NODE = 3;
-const DOCTYPE_NODE = 4;
-const Fragment = Symbol('Fragment');
-const VOID_TAGS = new Set([
-    'area',
-    'base',
-    'br',
-    'col',
-    'embed',
-    'hr',
-    'img',
-    'input',
-    'keygen',
-    'link',
-    'meta',
-    'param',
-    'source',
-    'track',
-    'wbr',
-]);
-const RAW_TAGS = new Set(['script', 'style']);
-const SPLIT_ATTRS_RE = /([@.a-z0-9_:-]*)\s*?=?\s*?(['"]?)([\s\S]*?)\2\s+/gim;
-const DOM_PARSER_RE = /(?:<(\/?)([a-zA-Z][a-zA-Z0-9:-]*)(?:\s([^>]*?))?((?:\s*\/)?)>|(<!--)([\s\S]*?)(-->)|(<!)([\s\S]*?)(>))/gm;
-function splitAttrs(str) {
-    const obj = {};
-    let token;
-    if (str) {
-        SPLIT_ATTRS_RE.lastIndex = 0;
-        str = ' ' + (str || '') + ' ';
-        while ((token = SPLIT_ATTRS_RE.exec(str))) {
-            if (token[0] === ' ')
-                continue;
-            obj[token[1]] = token[3];
-        }
-    }
-    return obj;
-}
-export function parse(str) {
-    let doc, parent, token, text, i, bStart, bText, bEnd, tag;
-    const tags = [];
-    DOM_PARSER_RE.lastIndex = 0;
-    parent = doc = {
-        type: DOCUMENT_NODE,
-        children: [],
-    };
-    let lastIndex = 0;
-    function commitTextNode() {
-        text = str.substring(lastIndex, DOM_PARSER_RE.lastIndex - token[0].length);
-        if (text) {
-            // eslint-disable-next-line
-            ;
-            parent.children.push({
-                type: TEXT_NODE,
-                value: text,
-                parent,
-            });
-        }
-    }
-    while ((token = DOM_PARSER_RE.exec(str))) {
-        bStart = token[5] || token[8];
-        bText = token[6] || token[9];
-        bEnd = token[7] || token[10];
-        if (RAW_TAGS.has(parent.name) && token[2] !== parent.name) {
-            i = DOM_PARSER_RE.lastIndex - token[0].length;
-            if (parent.children.length > 0) {
-                parent.children[0].value += token[0];
-            }
-            continue;
-        }
-        else if (bStart === '<!--') {
-            i = DOM_PARSER_RE.lastIndex - token[0].length;
-            if (RAW_TAGS.has(parent.name)) {
-                continue;
-            }
-            tag = {
-                type: COMMENT_NODE,
-                value: bText,
-                parent: parent,
-                loc: [
-                    {
-                        start: i,
-                        end: i + bStart.length,
-                    },
-                    {
-                        start: DOM_PARSER_RE.lastIndex - bEnd.length,
-                        end: DOM_PARSER_RE.lastIndex,
-                    },
-                ],
-            };
-            tags.push(tag);
-            tag.parent.children.push(tag);
-        }
-        else if (bStart === '<!') {
-            i = DOM_PARSER_RE.lastIndex - token[0].length;
-            tag = {
-                type: DOCTYPE_NODE,
-                value: bText,
-                parent: parent,
-                loc: [
-                    {
-                        start: i,
-                        end: i + bStart.length,
-                    },
-                    {
-                        start: DOM_PARSER_RE.lastIndex - bEnd.length,
-                        end: DOM_PARSER_RE.lastIndex,
-                    },
-                ],
-            };
-            // commitTextNode();
-            tags.push(tag);
-            tag.parent.children.push(tag);
-        }
-        else if (token[1] !== '/') {
-            commitTextNode();
-            if (RAW_TAGS.has(parent.name)) {
-                lastIndex = DOM_PARSER_RE.lastIndex;
-                commitTextNode();
-                continue;
-            }
-            else {
-                tag = {
-                    type: ELEMENT_NODE,
-                    name: token[2] + '',
-                    attributes: splitAttrs(token[3]),
-                    parent,
-                    children: [],
-                    loc: [
-                        {
-                            start: DOM_PARSER_RE.lastIndex - token[0].length,
-                            end: DOM_PARSER_RE.lastIndex,
-                        },
-                    ],
-                };
-                tags.push(tag);
-                tag.parent.children.push(tag);
-                if ((token[4] && token[4].indexOf('/') > -1) || VOID_TAGS.has(tag.name)) {
-                    tag.loc[1] = tag.loc[0];
-                    tag.isSelfClosingTag = true;
-                }
-                else {
-                    parent = tag;
-                }
-            }
-        }
-        else {
-            commitTextNode();
-            // Close parent node if end-tag matches
-            if (token[2] + '' === parent.name) {
-                tag = parent;
-                parent = tag.parent;
-                tag.loc.push({
-                    start: DOM_PARSER_RE.lastIndex - token[0].length,
-                    end: DOM_PARSER_RE.lastIndex,
-                });
-                text = str.substring(tag.loc[0].end, tag.loc[1].start);
-                if (tag.children.length === 0) {
-                    tag.children.push({
-                        type: TEXT_NODE,
-                        value: text,
-                        parent,
-                    });
-                }
-            }
-            // account for abuse of self-closing tags when an end-tag is also provided:
-            else if (token[2] + '' === tags[tags.length - 1].name &&
-                tags[tags.length - 1].isSelfClosingTag === true) {
-                tag = tags[tags.length - 1];
-                tag.loc.push({
-                    start: DOM_PARSER_RE.lastIndex - token[0].length,
-                    end: DOM_PARSER_RE.lastIndex,
-                });
-            }
-        }
-        lastIndex = DOM_PARSER_RE.lastIndex;
-    }
-    text = str.slice(lastIndex);
-    parent.children.push({
-        type: TEXT_NODE,
-        value: text,
-        parent,
-    });
-    return doc;
-}
-const HTMLString = Symbol('HTMLString');
-const AttrString = Symbol('AttrString');
-const RenderFn = Symbol('RenderFn');
-function mark(str, tags = [HTMLString]) {
-    const v = { value: str };
-    for (const tag of tags) {
-        Object.defineProperty(v, tag, {
-            value: true,
-            enumerable: false,
-            writable: false,
-        });
-    }
-    return v;
-}
-const ESCAPE_CHARS = {
-    '&': '&amp;',
-    '<': '&lt;',
-    '>': '&gt;',
-};
-function escapeHTML(str) {
-    return str.replace(/[&<>]/g, (c) => ESCAPE_CHARS[c] || c);
-}
-function attrs(attributes) {
-    let attrStr = '';
-    for (const [key, value] of Object.entries(attributes)) {
-        attrStr += ` ${key}="${value}"`;
-    }
-    return mark(attrStr, [HTMLString, AttrString]);
-}
-function renderElement(node) {
-    const { name, attributes = {} } = node;
-    const children = node.children.map((child) => render(child)).join('');
-    if (RenderFn in node) {
-        const value = node[RenderFn](attributes, mark(children));
-        if (value && value[HTMLString])
-            return value.value;
-        return escapeHTML(String(value));
-    }
-    if (name === Fragment)
-        return children;
-    if (VOID_TAGS.has(name)) {
-        return `<${node.name}${attrs(attributes).value}>`;
-    }
-    return `<${node.name}${attrs(attributes).value}>${children}</${node.name}>`;
-}
-export function render(node) {
-    switch (node.type) {
-        case DOCUMENT_NODE:
-            return node.children.map((child) => render(child)).join('');
-        case ELEMENT_NODE:
-            return renderElement(node);
-        case TEXT_NODE:
-            return `${node.value}`;
-        case COMMENT_NODE:
-            return `<!--${node.value}-->`;
-        case DOCTYPE_NODE:
-            return `<!${node.value}>`;
-    }
-}

package/source/pipe.js

@@ -1 +0,0 @@
-export const pipe = (arg, firstFn, ...fns) => fns.reduce((acc, fn) => fn(acc), firstFn(arg));

package/source/spread.js

@@ -1,40 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import { createMemo, mergeProps } from 'solid-js';
-import { spread as solidSpread } from 'solid-js/web';
-import { mergeStyle } from './merge-style';
-const getEventKey = (key) => `$$${key.toLowerCase().slice(2)}`;
-const hasOwn = (obj, key) => Object.prototype.hasOwnProperty.call(obj, key);
-function mapProps(props, mapper) {
-    return Object.fromEntries(Object.entries(props).map(([key, value]) => [key, mapper(key, value)]));
-}
-export const spread = (node, props) => {
-    const nodeEvents = Object.fromEntries(Object.keys(node)
-        .filter((prop) => prop.startsWith('$$'))
-        // @ts-expect-error - fix later
-        .map((prop) => [prop, node[prop]]));
-    const isSVG = node instanceof SVGElement;
-    const childProps = createMemo(() => mapProps(props, (key, value) => {
-        const eventKey = getEventKey(key);
-        // event composition
-        if (hasOwn(nodeEvents, eventKey)) {
-            return function next(...args) {
-                if (typeof value === 'function')
-                    value(...args);
-                nodeEvents[eventKey](...args);
-            };
-        }
-        // style composition
-        if (key === 'style') {
-            return mergeStyle(node.style.cssText, value);
-        }
-        // class composition
-        if (key === 'class') {
-            return [node.classList.toString(), value].filter(Boolean).join(' ');
-        }
-        // don't override existing child attributes
-        if (node.hasAttribute(key))
-            return;
-        return value;
-    }));
-    solidSpread(node, mergeProps(childProps), isSVG);
-};

package/source/ssr-spread.js

@@ -1,19 +0,0 @@
-import { filterBooleanAttributeValues, filterEmptyValues, filterFunctionValues, } from './filter-object';
-import { mergeStyle } from './merge-style';
-import { parse, render } from './parse-template';
-import { pipe } from './pipe';
-export const ssrSpread = (children, attributes) => {
-    if (isJSXElement(children))
-        return children;
-    const { t } = children;
-    const ast = parse(t);
-    const [node] = ast.children;
-    const mergedAttributes = Object.assign({}, attributes, {
-        class: [attributes?.class, node.attributes.class].filter(Boolean).join(' '),
-        style: mergeStyle(attributes.style, node.attributes.style),
-    });
-    const ssrAttributes = pipe(mergedAttributes, filterEmptyValues, filterFunctionValues, filterBooleanAttributeValues);
-    Object.assign(node.attributes, ssrAttributes);
-    return { t: render(ast) };
-};
-const isJSXElement = (children) => !Object.hasOwnProperty.call(children, 't');

package/types/accordion/accordion.d.ts

@@ -1,7 +0,0 @@
-import { type HTMLArkProps } from '../factory';
-import { type UsePresenceProps } from '../presence';
-import type { Assign } from '../types';
-import { type UseAccordionProps } from './use-accordion';
-export interface AccordionProps extends Assign<HTMLArkProps<'div'>, UseAccordionProps>, UsePresenceProps {
-}
-export declare const Accordion: (props: AccordionProps) => import("solid-js").JSX.Element;

package/types/accordion/index.d.ts

@@ -1,17 +0,0 @@
-import type { FocusChangeDetails as AccordionFocusChangeDetails, ValueChangeDetails as AccordionValueChangeDetails } from '@zag-js/accordion';
-import { type AccordionProps } from './accordion';
-import { useAccordionContext, type AccordionContext } from './accordion-context';
-import { AccordionItem, type AccordionItemProps } from './accordion-item';
-import { AccordionItemContent, type AccordionItemContentProps } from './accordion-item-content';
-import { useAccordionItemContext, type AccordionItemContext } from './accordion-item-context';
-import { AccordionItemIndicator, type AccordionItemIndicatorProps } from './accordion-item-indicator';
-import { AccordionItemTrigger, type AccordionItemTriggerProps } from './accordion-item-trigger';
-declare const Accordion: ((props: AccordionProps) => import("solid-js").JSX.Element) & {
-    Root: (props: AccordionProps) => import("solid-js").JSX.Element;
-    Item: (props: AccordionItemProps) => import("solid-js").JSX.Element;
-    ItemContent: (props: AccordionItemContentProps) => import("solid-js").JSX.Element;
-    ItemIndicator: (props: AccordionItemIndicatorProps) => import("solid-js").JSX.Element;
-    ItemTrigger: (props: AccordionItemTriggerProps) => import("solid-js").JSX.Element;
-};
-export { Accordion, AccordionItem, AccordionItemContent, AccordionItemIndicator, AccordionItemTrigger, useAccordionContext, useAccordionItemContext, };
-export type { AccordionContext, AccordionFocusChangeDetails, AccordionItemContentProps, AccordionItemContext, AccordionItemIndicatorProps, AccordionItemProps, AccordionItemTriggerProps, AccordionProps, AccordionValueChangeDetails, };

package/types/avatar/avatar.d.ts

@@ -1,6 +0,0 @@
-import { type HTMLArkProps } from '../factory';
-import type { Assign } from '../types';
-import { type UseAvatarProps } from './use-avatar';
-export interface AvatarProps extends Assign<HTMLArkProps<'div'>, UseAvatarProps> {
-}
-export declare const Avatar: (props: AvatarProps) => import("solid-js").JSX.Element;

package/types/carousel/carousel-slide-group.d.ts

@@ -1,4 +0,0 @@
-import { type HTMLArkProps } from '../factory';
-export interface CarouselItemGroupProps extends HTMLArkProps<'div'> {
-}
-export declare const CarouselItemGroup: (props: CarouselItemGroupProps) => import("solid-js").JSX.Element;