@pathscale/ui 2.12.0 → 3.1.0

package/dist/hooks/connection/createConnectionSettings.d.ts

@@ -0,0 +1,128 @@
+import type { Accessor } from "solid-js";
+/**
+ * Where an application points itself, and how that survives a reload.
+ *
+ * Every property in this family ships a "connection settings" page: a toggle,
+ * one or more backend URLs, an app id, and a save that reconfigures the
+ * transport. Six of them had written it separately, in two different shapes and
+ * with different bugs, which is what this replaces.
+ *
+ * The storage model is per-endpoint rather than global. Four sites had a single
+ * `useCustomUrl` covering every backend at once; two had already grown a flag
+ * per backend, because pointing the API at a local instance while leaving auth
+ * on production is the ordinary case. Per-endpoint is the shape that covers
+ * both, and {@link ConnectionSettingsStore.setUseCustom} flips them together
+ * for a page that only wants one switch.
+ */
+export interface ConnectionEndpoint {
+    /** Stable key. Names the value in storage and in {@link ConnectionSettingsStore.urls}. */
+    name: string;
+    /** The address used whenever this endpoint's override is off. */
+    fallback: string;
+    /**
+     * Reject an address before it is saved. Return a message to refuse it, or
+     * nothing to accept.
+     *
+     * Defaults to {@link isAbsoluteUrl}: the value has to parse as an absolute
+     * URL. That is deliberately weak, because this hook does not know what a
+     * given endpoint speaks. An endpoint that knows should say so -- a WebSocket
+     * transport handed `http://…` fails at connect time, long after the page
+     * that could have explained it has gone.
+     */
+    validate?: (url: string) => string | undefined;
+}
+/** What {@link ConnectionSettingsStore.apply} hands to `onApply`. */
+export interface ConnectionSettingsApplied {
+    /** Resolved per endpoint, overrides taken into account. Never empty. */
+    urls: Readonly<Record<string, string>>;
+    appPublicId: string;
+    /** Which endpoints the resolved address came from an override for. */
+    overrides: Readonly<Record<string, boolean>>;
+}
+/**
+ * Whether a bracketed host is an IPv6 literal.
+ *
+ * `https://[1:2:3]` is not an address, and a character class of hex digits and
+ * colons said it was. This is the shape the URL Standard describes: eight
+ * 16-bit groups, or fewer with exactly one `::` standing for the run of zeroes
+ * it elides, optionally ending in a dotted IPv4 form.
+ *
+ * Written out rather than folded into one pattern because the `::` rule is a
+ * count, not a shape: each half has to parse, and together they have to leave
+ * at least one group for the `::` to stand for.
+ */
+export declare const isIpv6Literal: (host: string) => boolean;
+export declare const isAbsoluteUrl: (url: string) => string | undefined;
+export interface ConnectionSettingsOptions {
+    /** `localStorage` key. Namespace it per application; two apps on one origin would collide. */
+    storageKey: string;
+    endpoints: readonly ConnectionEndpoint[];
+    /** The application's own id, when it has one. Stored alongside the URLs. */
+    appPublicId?: string;
+    /**
+     * Run after a successful save or reset, with everything that was applied.
+     *
+     * This is where an application reconfigures its transport. It is awaited, so
+     * `isApplying` covers the reconnect rather than just the write.
+     *
+     * It receives the whole applied state, not only the URLs: a site that stores
+     * an app id here reconfigures its identity from the same call, and passing
+     * the URLs alone left it reaching back into the store it had just handed to
+     * this hook.
+     */
+    onApply?: (applied: ConnectionSettingsApplied) => void | Promise<void>;
+}
+export interface ConnectionSettingsState {
+    /** Per endpoint: is the override in use. Absent means no. */
+    overrides: Record<string, boolean>;
+    /** Per endpoint: the address to use when its override is on. */
+    urls: Record<string, string>;
+    appPublicId: string;
+}
+export interface ConnectionSettingsStore {
+    /** What is stored, override flags included. Read this to populate a form. */
+    readonly state: ConnectionSettingsState;
+    /**
+     * The address for each endpoint after overrides are applied. This is what a
+     * transport should read; it never contains an empty string.
+     */
+    readonly urls: Readonly<Record<string, string>>;
+    /** The address each endpoint falls back to, by name. What "not overridden" means. */
+    readonly fallbacks: Readonly<Record<string, string>>;
+    /** True while `onApply` is in flight. */
+    readonly isApplying: boolean;
+    /** Nothing has been overridden and the app id is untouched. */
+    readonly isAtDefaults: boolean;
+    /** True when this endpoint is overridden. */
+    isOverridden(name: string): boolean;
+    /**
+     * Why this address cannot be saved for this endpoint, or `undefined` if it
+     * can. Empty is always refused; beyond that the endpoint's own `validate`
+     * decides, defaulting to {@link isAbsoluteUrl}.
+     *
+     * A settings page is the last place able to explain a bad address. Saved
+     * unchecked, the value survives a failed reconnect and is still there on the
+     * next launch, with nothing on screen saying why nothing connects.
+     */
+    validate(name: string, url: string): string | undefined;
+    /**
+     * Set an endpoint's override.
+     *
+     * Returns the reason it was refused, or `undefined` when it was stored. A
+     * value written here becomes an active, persisted override, so it has to
+     * pass the same check {@link ConnectionSettingsStore.validate} applies;
+     * an invalid one is not stored at all. Keep it as a draft in the UI instead.
+     */
+    setUrl(name: string, url: string): string | undefined;
+    setOverride(name: string, on: boolean): void;
+    /** Flip every endpoint together, for a page with one switch. */
+    setUseCustom(on: boolean): void;
+    setAppPublicId(id: string): void;
+    /** Drop every override and forget the stored copy. Does not apply. */
+    reset(): void;
+    /** Persist, then hand the resolved addresses to `onApply`. */
+    apply(): Promise<void>;
+    /** For a component that wants to track the state rather than read it once. */
+    state$: Accessor<ConnectionSettingsState>;
+}
+export declare const createConnectionSettings: (options: ConnectionSettingsOptions) => ConnectionSettingsStore;

package/dist/hooks/connection/createConnectionSettings.js

@@ -0,0 +1,211 @@
+import { createEffect, createRoot, createSignal } from "solid-js";
+const ABSOLUTE_URL = /^[a-z][a-z0-9+.-]*:\/\/(\[[^\]\s]*\]|[^\s/?#:]+)(?::(\d{1,5}))?(?:[/?#]\S*)?$/i;
+const IPV6_GROUP = "[0-9a-f]{1,4}";
+const IPV4_TAIL = "(?:(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)\\.){3}(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)";
+const IPV6_FULL = new RegExp(`^(?:${IPV6_GROUP}:){6}(?:${IPV6_GROUP}:${IPV6_GROUP}|${IPV4_TAIL})$`, "i");
+const IPV6_PIECES = new RegExp(`^(?:${IPV6_GROUP}(?::${IPV6_GROUP})*)?$`, "i");
+const isIpv6Literal = (host)=>{
+    if (IPV6_FULL.test(host)) return true;
+    const halves = host.split("::");
+    if (2 !== halves.length) return false;
+    const [head, tail] = halves;
+    const embeddedV4 = new RegExp(`(?:^|:)(${IPV4_TAIL})$`, "i").exec(tail);
+    const groups = embeddedV4 ? tail.slice(0, tail.length - embeddedV4[1].length).replace(/:$/, "") : tail;
+    if (!IPV6_PIECES.test(head)) return false;
+    if (!IPV6_PIECES.test(groups)) return false;
+    const count = (part)=>"" === part ? 0 : part.split(":").length;
+    return count(head) + count(groups) + (embeddedV4 ? 2 : 0) <= 7;
+};
+const isAbsoluteUrl = (url)=>{
+    const match = ABSOLUTE_URL.exec(url);
+    if (!match) return `${url} is not an absolute address (expected scheme://host)`;
+    const [, host, port] = match;
+    if (host.startsWith("[") && !isIpv6Literal(host.slice(1, -1))) return `${url} does not contain a valid IPv6 address`;
+    if (void 0 !== port && Number(port) > 65535) return `${url} has a port outside 0-65535`;
+};
+const isRecord = (value)=>"object" == typeof value && null !== value && !Array.isArray(value);
+const createConnectionSettings = (options)=>{
+    const { storageKey, endpoints, appPublicId = "", onApply } = options;
+    const fallbacks = Object.freeze(Object.fromEntries(endpoints.map((e)=>[
+            e.name,
+            e.fallback
+        ])));
+    const defaults = ()=>({
+            overrides: {},
+            urls: Object.fromEntries(endpoints.map((e)=>[
+                    e.name,
+                    e.fallback
+                ])),
+            appPublicId
+        });
+    const read = ()=>{
+        const base = defaults();
+        try {
+            if ("u" < typeof localStorage) return base;
+            const raw = localStorage.getItem(storageKey);
+            if (!raw) return base;
+            const parsed = JSON.parse(raw);
+            if (!isRecord(parsed)) return base;
+            const overrides = {};
+            const urls = {
+                ...base.urls
+            };
+            const storedOverrides = isRecord(parsed.overrides) ? parsed.overrides : {};
+            const storedUrls = isRecord(parsed.urls) ? parsed.urls : {};
+            for (const endpoint of endpoints){
+                const url = storedUrls[endpoint.name];
+                const usable = "string" == typeof url && "" !== url && void 0 === (endpoint.validate ?? isAbsoluteUrl)(url);
+                if (usable) urls[endpoint.name] = url;
+                if (usable && true === storedOverrides[endpoint.name]) overrides[endpoint.name] = true;
+            }
+            return {
+                overrides,
+                urls,
+                appPublicId: "string" == typeof parsed.appPublicId ? parsed.appPublicId : base.appPublicId
+            };
+        } catch  {
+            return base;
+        }
+    };
+    const [state, setState, isApplying, setIsApplying] = createRoot(()=>{
+        const [s, setS] = createSignal(read());
+        const [a, setA] = createSignal(false);
+        return [
+            s,
+            setS,
+            a,
+            setA
+        ];
+    });
+    const atDefaults = (value)=>value.appPublicId === appPublicId && endpoints.every((e)=>true !== value.overrides[e.name] && value.urls[e.name] === e.fallback);
+    const write = (value)=>{
+        try {
+            if ("u" < typeof localStorage) return;
+            if (atDefaults(value)) localStorage.removeItem(storageKey);
+            else localStorage.setItem(storageKey, JSON.stringify(value));
+        } catch  {}
+    };
+    createRoot(()=>{
+        createEffect(()=>state(), (value)=>{
+            write(value);
+        });
+    });
+    let committed = state();
+    let inFlight = 0;
+    let queue = Promise.resolve();
+    const update = (change)=>{
+        committed = change(committed);
+        setState(committed);
+    };
+    const resolveFrom = (current)=>Object.fromEntries(endpoints.map((e)=>{
+            const override = true === current.overrides[e.name] ? current.urls[e.name] : void 0;
+            return [
+                e.name,
+                override && "" !== override ? override : e.fallback
+            ];
+        }));
+    let resolvedFor;
+    let resolvedValue = Object.freeze({});
+    const resolved = ()=>{
+        const current = state();
+        if (resolvedFor !== current) {
+            resolvedFor = current;
+            resolvedValue = Object.freeze(resolveFrom(current));
+        }
+        return resolvedValue;
+    };
+    return {
+        get state () {
+            return state();
+        },
+        get urls () {
+            return resolved();
+        },
+        validate (name, url) {
+            const endpoint = endpoints.find((e)=>e.name === name);
+            if (!endpoint) return `${name} is not a configured endpoint`;
+            if ("" === url) return "an address is required";
+            return (endpoint.validate ?? isAbsoluteUrl)(url);
+        },
+        get fallbacks () {
+            return fallbacks;
+        },
+        get isApplying () {
+            return isApplying();
+        },
+        get isAtDefaults () {
+            state();
+            return atDefaults(committed);
+        },
+        state$: state,
+        isOverridden (name) {
+            return true === state().overrides[name];
+        },
+        setUrl (name, url) {
+            if ("" !== url) {
+                const endpoint = endpoints.find((e)=>e.name === name);
+                const problem = endpoint ? (endpoint.validate ?? isAbsoluteUrl)(url) : `${name} is not a configured endpoint`;
+                if (problem) return problem;
+            }
+            update((c)=>({
+                    ...c,
+                    urls: {
+                        ...c.urls,
+                        [name]: url
+                    }
+                }));
+        },
+        setOverride (name, on) {
+            update((c)=>({
+                    ...c,
+                    overrides: {
+                        ...c.overrides,
+                        [name]: on
+                    }
+                }));
+        },
+        setUseCustom (on) {
+            update((c)=>({
+                    ...c,
+                    overrides: Object.fromEntries(endpoints.map((e)=>[
+                            e.name,
+                            on
+                        ]))
+                }));
+        },
+        setAppPublicId (id) {
+            update((c)=>({
+                    ...c,
+                    appPublicId: id
+                }));
+        },
+        reset () {
+            committed = defaults();
+            setState(committed);
+        },
+        async apply () {
+            inFlight += 1;
+            setIsApplying(true);
+            const current = committed;
+            const reconnect = ()=>{
+                write(current);
+                return onApply?.({
+                    urls: resolveFrom(current),
+                    appPublicId: current.appPublicId,
+                    overrides: {
+                        ...current.overrides
+                    }
+                }) ?? void 0;
+            };
+            const run = 1 === inFlight ? (async ()=>reconnect())() : queue.then(reconnect).then(()=>void 0);
+            queue = run.catch(()=>void 0);
+            try {
+                await run;
+            } finally{
+                inFlight -= 1;
+                if (0 === inFlight) setIsApplying(false);
+            }
+        }
+    };
+};
+export { createConnectionSettings, isAbsoluteUrl, isIpv6Literal };

package/dist/hooks/connection/index.d.ts

@@ -0,0 +1,2 @@
+export type { ConnectionEndpoint, ConnectionSettingsApplied, ConnectionSettingsOptions, ConnectionSettingsState, ConnectionSettingsStore, } from "./createConnectionSettings";
+export { createConnectionSettings, isAbsoluteUrl } from "./createConnectionSettings";

package/dist/hooks/connection/index.js

@@ -0,0 +1 @@
+export { createConnectionSettings, isAbsoluteUrl } from "./createConnectionSettings.js";

package/dist/hooks/data/createMutation.d.ts

@@ -1,9 +1,8 @@
-import type { Accessor } from "solid-js";
 /**
  * A write, without a query library. The companion to `createQuery`.
  *
  * Replaces `useMutation`. The same rule applies as there: reading this never
- * suspends and never throws. `mutate` reports failure through `error()`;
+ * suspends and never throws. `mutate` reports failure through `error`;
  * `mutateAsync` rejects, for a caller that wants to await and handle it.
  */
 export interface CreateMutationOptions<TArgs extends unknown[], TResult> {
@@ -13,15 +12,17 @@ export interface CreateMutationOptions<TArgs extends unknown[], TResult> {
     /** Runs after success or failure, like TanStack's `onSettled`. */
     onSettled?: () => void | Promise<void>;
 }
+/** Read as properties, for the same reason as `QueryResult`. */
 export interface MutationResult<TArgs extends unknown[], TResult> {
-    /** Fire and forget. Failure lands on `error()` rather than as a rejection. */
+    /** Fire and forget. Failure lands on `error` rather than as a rejection. */
     mutate: (...args: TArgs) => void;
     /** Fire and await. Rejects on failure. */
     mutateAsync: (...args: TArgs) => Promise<TResult>;
-    isPending: Accessor<boolean>;
-    error: Accessor<unknown>;
+    readonly isPending: boolean;
+    readonly error: unknown;
+    readonly isError: boolean;
     /** The last successful result. */
-    data: Accessor<TResult | undefined>;
+    readonly data: TResult | undefined;
     /** Clear `error` and `data`. */
     reset: () => void;
 }

package/dist/hooks/data/createMutation.js

@@ -29,9 +29,18 @@ const createMutation = (options)=>{
             mutateAsync(...args).catch(()=>{});
         },
         mutateAsync,
-        isPending,
-        error,
-        data,
+        get isPending () {
+            return isPending();
+        },
+        get error () {
+            return error();
+        },
+        get isError () {
+            return void 0 !== error();
+        },
+        get data () {
+            return data();
+        },
         reset: ()=>{
             setError(void 0);
             setData(()=>void 0);

package/dist/hooks/data/createQuery.d.ts

@@ -1,4 +1,3 @@
-import type { Accessor } from "solid-js";
 /**
  * Asynchronous reads, without a query library.
  *
@@ -16,7 +15,7 @@ import type { Accessor } from "solid-js";
  * had nothing to print. That is how a support-chat button that had not
  * connected replaced an entire application with a blank error page.
  *
- * Here, `data()` is `undefined` until there is data, `isLoading()` is true only
+ * Here, `data` is `undefined` until there is data, `isLoading` is true only
  * while a fetch is actually in flight, and neither ever throws. A caller that
  * wants to suspend can do so explicitly; a caller that forgets cannot take the
  * page down.
@@ -32,15 +31,41 @@ export interface CreateQueryOptions<T> {
     /** Held back while false. Default true. */
     enabled?: boolean;
 }
+/**
+ * Read as properties, not as accessors.
+ *
+ * `solid-query` returned a store, so every consumer of it is written
+ * `query.data`, `query.isLoading`, `query.isError` -- roughly three thousand
+ * such reads across these applications. Exposing accessors here would mean
+ * editing all of them to add `()`, turning a migration of the ~300 files that
+ * *define* queries into one that touches every file that reads one.
+ *
+ * These are getters over signals, so a read inside a tracked scope still
+ * subscribes exactly as an accessor call would.
+ */
 export interface QueryResult<T> {
     /** The last value read, or `undefined` before the first one arrives. */
-    data: Accessor<T | undefined>;
+    readonly data: T | undefined;
     /** The last failure, cleared by the next successful read. */
-    error: Accessor<unknown>;
+    readonly error: unknown;
     /** True only while a fetch is in flight. Never true for a disabled query. */
-    isLoading: Accessor<boolean>;
+    readonly isLoading: boolean;
+    /**
+     * Alias of `isLoading`, for call sites carried over from `solid-query`.
+     *
+     * Note the deliberate difference in meaning. There, `isPending` was "has no
+     * data", which stayed true forever for a query held back by `enabled: false`
+     * -- so `if (isPending) return <Spinner/>` spun for the life of the page.
+     * Here it means "a fetch is in flight", so a disabled query reads as not
+     * pending and its consumer renders instead of hanging.
+     */
+    readonly isPending: boolean;
+    /** True when the last read failed. */
+    readonly isError: boolean;
+    /** True when a value has arrived and the last read did not fail. */
+    readonly isSuccess: boolean;
     /** True once a value has arrived at least once. */
-    isReady: Accessor<boolean>;
+    readonly isReady: boolean;
     /** Read again now, regardless of `enabled`. */
     refetch: () => Promise<void>;
 }

package/dist/hooks/data/createQuery.js

@@ -45,10 +45,27 @@ const createQuery = (options)=>{
         generation++;
     });
     return {
-        data,
-        error,
-        isLoading,
-        isReady,
+        get data () {
+            return data();
+        },
+        get error () {
+            return error();
+        },
+        get isLoading () {
+            return isLoading();
+        },
+        get isPending () {
+            return isLoading();
+        },
+        get isError () {
+            return void 0 !== error();
+        },
+        get isSuccess () {
+            return isReady() && void 0 === error();
+        },
+        get isReady () {
+            return isReady();
+        },
         refetch: run
     };
 };

package/dist/hooks/data/createQuery.test.js

@@ -1,5 +1,5 @@
 import { describe, expect, test } from "bun:test";
-import { createRoot, flush } from "solid-js";
+import { createRenderEffect, createRoot, flush } from "solid-js";
 import { createMutation } from "./createMutation.js";
 import { createQuery, invalidateQueries } from "./createQuery.js";
 const tick = ()=>new Promise((resolve)=>setTimeout(resolve, 0));
@@ -17,9 +17,9 @@ describe("createQuery", ()=>{
                         return "value";
                     }
                 }));
-            expect(q.isLoading()).toBe(false);
-            expect(q.data()).toBeUndefined();
-            expect(q.isReady()).toBe(false);
+            expect(q.isLoading).toBe(false);
+            expect(q.data).toBeUndefined();
+            expect(q.isReady).toBe(false);
             return d;
         });
         await tick();
@@ -37,15 +37,15 @@ describe("createQuery", ()=>{
                 }));
             flush();
             const whileLoading = {
-                loading: q.isLoading(),
-                ready: q.isReady()
+                loading: q.isLoading,
+                ready: q.isReady
             };
             resolveFetch?.("hello");
             await tick();
             return {
                 whileLoading,
-                data: q.data(),
-                ready: q.isReady(),
+                data: q.data,
+                ready: q.isReady,
                 dispose
             };
         });
@@ -57,7 +57,7 @@ describe("createQuery", ()=>{
         expect(result.ready).toBe(true);
         result.dispose();
     });
-    test("a failure lands on error() rather than being thrown", async ()=>{
+    test("a failure lands on error rather than being thrown", async ()=>{
         const result = await createRoot(async (dispose)=>{
             const q = createQuery(()=>({
                     key: [
@@ -70,8 +70,8 @@ describe("createQuery", ()=>{
             flush();
             await tick();
             return {
-                error: q.error(),
-                loading: q.isLoading(),
+                error: q.error,
+                loading: q.isLoading,
                 dispose
             };
         });
@@ -134,6 +134,33 @@ describe("createQuery", ()=>{
         expect(calls).toBe(1);
     });
 });
+describe("property reads stay reactive", ()=>{
+    test("a tracked scope re-runs when data lands", async ()=>{
+        let resolveFetch;
+        const seen = [];
+        const result = await createRoot(async (dispose)=>{
+            const q = createQuery(()=>({
+                    key: [
+                        "reactive"
+                    ],
+                    fetcher: ()=>new Promise((r)=>resolveFetch = r)
+                }));
+            createRenderEffect(()=>q.data, (value)=>{
+                seen.push(value);
+            });
+            flush();
+            resolveFetch?.("arrived");
+            await tick();
+            flush();
+            return {
+                dispose
+            };
+        });
+        expect(seen[0]).toBeUndefined();
+        expect(seen.at(-1)).toBe("arrived");
+        result.dispose();
+    });
+});
 describe("createMutation", ()=>{
     test("mutate reports failure without an unhandled rejection", async ()=>{
         const result = await createRoot(async (dispose)=>{
@@ -145,8 +172,8 @@ describe("createMutation", ()=>{
             m.mutate();
             await tick();
             return {
-                error: m.error(),
-                pending: m.isPending(),
+                error: m.error,
+                pending: m.isPending,
                 dispose
             };
         });
@@ -166,7 +193,7 @@ describe("createMutation", ()=>{
             const value = await m.mutateAsync("app");
             return {
                 value,
-                data: m.data(),
+                data: m.data,
                 dispose
             };
         });

package/dist/index.d.ts

@@ -20,7 +20,7 @@ export type { ButtonProps } from "./components/button";
 export { default as Button } from "./components/button";
 export { PanelToggle, type PanelToggleProps, type PanelToggleSide, } from "./components/panel-toggle";
 export { type CalendarDayHoverHandler, type CalendarDaySelectHandler, type CalendarProps, type CalendarSelectionMode, type CalendarWeekdayFormat, default as Calendar, } from "./components/calendar";
-export type { CardElevation, CardMaterial, CardProps, CardSectionProps, } from "./components/card";
+export type { CardElevation, CardMaterial, CardState, CardProps, CardSectionProps, } from "./components/card";
 export { Card as CardRoot, CardBody, CardFooter, CardHeader, default as Card, } from "./components/card";
 export { default as ChatBubble } from "./components/chatbubble";
 export { default as Checkbox } from "./components/checkbox";
@@ -123,6 +123,10 @@ export type { AnyFormApi, CreateFormOptions, FormApi, UseFieldResult, } from "./
 export { createForm, FormContext, getFirstFieldError, useField, useFormContext, } from "./hooks/form";
 export type { CreateMutationOptions, CreateQueryOptions, MutationResult, QueryResult, } from "./hooks/data";
 export { createMutation, createQuery, invalidateQueries, } from "./hooks/data";
+export type { ConnectionEndpoint, ConnectionSettingsApplied, ConnectionSettingsOptions, ConnectionSettingsState, ConnectionSettingsStore, } from "./hooks/connection";
+export { createConnectionSettings, isAbsoluteUrl } from "./hooks/connection";
+export type { ConnectionSettingsEndpointLabel, ConnectionSettingsLabels, ConnectionSettingsProps, } from "./components/connection-settings";
+export { ConnectionSettings } from "./components/connection-settings";
 export { useDesktop } from "./hooks/layout";
 export type { UseAnchoredOverlayPositionOptions } from "./hooks/table";
 export { useAnchoredOverlayPosition } from "./hooks/table";

package/dist/index.js

@@ -73,6 +73,8 @@ export { TooltipArrow, TooltipContent, TooltipTrigger, default as Tooltip } from
 export { FLAVORS, SIZES, SPACES, STATES, VARIANTS, isInvalid, resolveState } from "./components/vocabulary.js";
 export { FormContext, createForm, getFirstFieldError, useField, useFormContext } from "./hooks/form/index.js";
 export { createMutation, createQuery, invalidateQueries } from "./hooks/data/index.js";
+export { createConnectionSettings, isAbsoluteUrl } from "./hooks/connection/index.js";
+export { ConnectionSettings } from "./components/connection-settings/index.js";
 export { useDesktop } from "./hooks/layout/index.js";
 export { useAnchoredOverlayPosition } from "./hooks/table/index.js";
 export { evaluatePasswordRules, matchPasswordConfirmation } from "./passwordRules.js";

package/dist/layouts.manifest.json

@@ -1,7 +1,7 @@
 {
   "format": "solid-layouts-library-v2",
   "package": "@pathscale/ui",
-  "version": "2.12.0",
+  "version": "3.1.0",
   "components": {
     "Accordion": {
       "kind": "embedded"