alinea 2.0.0-preview.3 → 2.0.0-preview.4

package/dist/chunks/chunk-D6UJHBJJ.js

@@ -0,0 +1,183 @@
+import {
+  KEY_registerAbortHandler,
+  createStore,
+  getBuildingBlocks,
+  getDefaultStore
+} from "./chunk-CFNRVI3Y.js";
+
+// node_modules/jotai/dist/react/Provider.js
+import { createContext, createElement, useContext, useRef } from "react";
+var StoreContext = createContext(void 0);
+function useStore(options) {
+  const store = useContext(StoreContext);
+  return options?.store || store || getDefaultStore();
+}
+function Provider({ children, store }) {
+  const storeRef = useRef(null);
+  if (store) {
+    return createElement(StoreContext.Provider, { value: store }, children);
+  }
+  if (storeRef.current === null) {
+    storeRef.current = createStore();
+  }
+  return createElement(StoreContext.Provider, {
+    // TODO: If this is not a false positive, consider using useState instead of useRef like https://github.com/pmndrs/jotai/pull/2771
+    // eslint-disable-next-line react-hooks/refs
+    value: storeRef.current
+  }, children);
+}
+
+// node_modules/jotai/dist/react/useAtomValueRaw.js
+import { useDebugValue, useEffect, useReducer } from "react";
+
+// node_modules/jotai/dist/react/continuablePromise.js
+var isPromiseLike = (x) => typeof x?.then === "function";
+var continuablePromiseMap = /* @__PURE__ */ new WeakMap();
+var createContinuablePromise = (store, promise, getValue) => {
+  const buildingBlocks = getBuildingBlocks(store);
+  const registerAbortHandler = buildingBlocks[KEY_registerAbortHandler];
+  let continuablePromise = continuablePromiseMap.get(promise);
+  if (!continuablePromise) {
+    continuablePromise = new Promise((resolve, reject) => {
+      let curr = promise;
+      const onFulfilled = (me) => (v) => {
+        if (curr === me) {
+          resolve(v);
+        }
+      };
+      const onRejected = (me) => (e) => {
+        if (curr === me) {
+          reject(e);
+        }
+      };
+      const onAbort = () => {
+        try {
+          const nextValue = getValue();
+          if (isPromiseLike(nextValue)) {
+            continuablePromiseMap.set(nextValue, continuablePromise);
+            curr = nextValue;
+            nextValue.then(onFulfilled(nextValue), onRejected(nextValue));
+            registerAbortHandler(buildingBlocks, store, nextValue, onAbort);
+          } else {
+            resolve(nextValue);
+          }
+        } catch (e) {
+          reject(e);
+        }
+      };
+      promise.then(onFulfilled(promise), onRejected(promise));
+      registerAbortHandler(buildingBlocks, store, promise, onAbort);
+    });
+    continuablePromiseMap.set(promise, continuablePromise);
+  }
+  return continuablePromise;
+};
+
+// node_modules/jotai/dist/react/useAtomValueRaw.js
+function useAtomValueRaw(atom, options) {
+  const store = useStore(options);
+  const [[valueFromReducer, storeFromReducer, atomFromReducer], rerender] = useReducer((prev) => {
+    const nextValue = store.get(atom);
+    if (Object.is(prev[0], nextValue) && prev[1] === store && prev[2] === atom) {
+      return prev;
+    }
+    return [nextValue, store, atom];
+  }, void 0, () => [store.get(atom), store, atom]);
+  let value = valueFromReducer;
+  if (storeFromReducer !== store || atomFromReducer !== atom) {
+    rerender();
+    value = store.get(atom);
+  }
+  useEffect(() => store.sub(atom, rerender), [store, atom]);
+  useDebugValue(value);
+  if (isPromiseLike(value)) {
+    return createContinuablePromise(store, value, () => store.get(atom));
+  }
+  return value;
+}
+
+// node_modules/jotai/dist/react/useAtomValueRawSync.js
+import { useCallback, useDebugValue as useDebugValue2, useSyncExternalStore } from "react";
+function useAtomValueRawSync(atom, options) {
+  const store = useStore(options);
+  const getSnapshot = useCallback(() => {
+    const value2 = store.get(atom);
+    if (isPromiseLike(value2)) {
+      return createContinuablePromise(store, value2, () => store.get(atom));
+    }
+    return value2;
+  }, [store, atom]);
+  const value = useSyncExternalStore(useCallback((callback) => store.sub(atom, callback), [store, atom]), getSnapshot, getSnapshot);
+  useDebugValue2(value);
+  return value;
+}
+
+// node_modules/jotai/dist/react/useSetAtom.js
+import { useCallback as useCallback2 } from "react";
+function useSetAtom(atom, options) {
+  const store = useStore(options);
+  const setAtom = useCallback2((...args) => {
+    if (process.env.NODE_ENV !== "production" && !("write" in atom)) {
+      throw new Error("not writable atom");
+    }
+    return store.set(atom, ...args);
+  }, [store, atom]);
+  return setAtom;
+}
+
+// node_modules/jotai/dist/react/useAtomValue.js
+import React from "react";
+var attachPromiseStatus = (promise) => {
+  if (!promise.status) {
+    promise.status = "pending";
+    promise.then((v) => {
+      promise.status = "fulfilled";
+      promise.value = v;
+    }, (e) => {
+      promise.status = "rejected";
+      promise.reason = e;
+    });
+  }
+};
+var use = React.use || // A shim for older React versions
+((promise) => {
+  if (promise.status === "pending") {
+    throw promise;
+  } else if (promise.status === "fulfilled") {
+    return promise.value;
+  } else if (promise.status === "rejected") {
+    throw promise.reason;
+  } else {
+    attachPromiseStatus(promise);
+    throw promise;
+  }
+});
+function useAtomValue(atom, options) {
+  const { unstable_promiseStatus: promiseStatus = !React.use } = options || {};
+  const value = useAtomValueRaw(atom, options);
+  if (isPromiseLike(value)) {
+    if (promiseStatus) {
+      attachPromiseStatus(value);
+    }
+    return use(value);
+  }
+  return value;
+}
+
+// node_modules/jotai/dist/react/useAtom.js
+function useAtom(atom, options) {
+  return [
+    useAtomValue(atom, options),
+    // We do wrong type assertion here, which results in throwing an error.
+    useSetAtom(atom, options)
+  ];
+}
+
+export {
+  useStore,
+  Provider,
+  useAtomValueRaw,
+  useAtomValueRawSync,
+  useSetAtom,
+  useAtom
+};

package/dist/chunks/chunk-TIJTT5ZI.js

@@ -0,0 +1,228 @@
+import {
+  atom
+} from "./chunk-CFNRVI3Y.js";
+
+// node_modules/jotai/dist/vanilla/utils/selectAtom.js
+var getCached = (c, m, k) => (m.has(k) ? m : m.set(k, c())).get(k);
+var cache1 = /* @__PURE__ */ new WeakMap();
+var memo3 = (create, dep1, dep2, dep3) => {
+  const cache2 = getCached(() => /* @__PURE__ */ new WeakMap(), cache1, dep1);
+  const cache3 = getCached(() => /* @__PURE__ */ new WeakMap(), cache2, dep2);
+  return getCached(create, cache3, dep3);
+};
+function selectAtom(anAtom, selector, equalityFn = Object.is) {
+  return memo3(() => {
+    const EMPTY = /* @__PURE__ */ Symbol();
+    const selectValue = ([value, prevSlice]) => {
+      if (prevSlice === EMPTY) {
+        return selector(value);
+      }
+      const slice = selector(value, prevSlice);
+      return equalityFn(prevSlice, slice) ? prevSlice : slice;
+    };
+    const derivedAtom = atom((get) => {
+      const prev = get(derivedAtom);
+      const value = get(anAtom);
+      return selectValue([value, prev]);
+    });
+    derivedAtom.init = EMPTY;
+    return derivedAtom;
+  }, anAtom, selector, equalityFn);
+}
+
+// node_modules/jotai/dist/vanilla/utils/constants.js
+var RESET = /* @__PURE__ */ Symbol(process.env.NODE_ENV !== "production" ? "RESET" : "");
+
+// node_modules/jotai/dist/vanilla/utils/atomWithStorage.js
+var isPromiseLike = (x) => typeof x?.then === "function";
+function createJSONStorage(getStringStorage = () => {
+  try {
+    return window.localStorage;
+  } catch (e) {
+    if (process.env.NODE_ENV !== "production") {
+      if (typeof window !== "undefined") {
+        console.warn(e);
+      }
+    }
+    return void 0;
+  }
+}, options) {
+  let lastStr;
+  let lastValue;
+  const storage = {
+    getItem: (key, initialValue) => {
+      const parse = (str2) => {
+        str2 = str2 || "";
+        if (lastStr !== str2) {
+          try {
+            lastValue = JSON.parse(str2, options?.reviver);
+          } catch {
+            return initialValue;
+          }
+          lastStr = str2;
+        }
+        return lastValue;
+      };
+      const str = getStringStorage()?.getItem(key) ?? null;
+      if (isPromiseLike(str)) {
+        return str.then(parse);
+      }
+      return parse(str);
+    },
+    setItem: (key, newValue) => getStringStorage()?.setItem(key, JSON.stringify(newValue, options?.replacer)),
+    removeItem: (key) => getStringStorage()?.removeItem(key)
+  };
+  const createHandleSubscribe = (subscriber2) => (key, callback, initialValue) => subscriber2(key, (v) => {
+    let newValue;
+    try {
+      newValue = JSON.parse(v || "", options?.reviver);
+    } catch {
+      newValue = initialValue;
+    }
+    callback(newValue);
+  });
+  let subscriber;
+  try {
+    subscriber = getStringStorage()?.subscribe;
+  } catch {
+  }
+  if (!subscriber && typeof window !== "undefined" && typeof window.addEventListener === "function" && window.Storage) {
+    subscriber = (key, callback) => {
+      if (!(getStringStorage() instanceof window.Storage)) {
+        return () => {
+        };
+      }
+      const storageEventCallback = (e) => {
+        if (e.storageArea === getStringStorage() && e.key === key) {
+          callback(e.newValue);
+        }
+      };
+      window.addEventListener("storage", storageEventCallback);
+      return () => {
+        window.removeEventListener("storage", storageEventCallback);
+      };
+    };
+  }
+  if (subscriber) {
+    storage.subscribe = createHandleSubscribe(subscriber);
+  }
+  return storage;
+}
+var defaultStorage = createJSONStorage();
+function atomWithStorage(key, initialValue, storage = defaultStorage, options) {
+  const getOnInit = options?.getOnInit;
+  const baseAtom = atom(getOnInit ? storage.getItem(key, initialValue) : initialValue);
+  if (process.env.NODE_ENV !== "production") {
+    baseAtom.debugPrivate = true;
+  }
+  baseAtom.onMount = (setAtom) => {
+    setAtom(storage.getItem(key, initialValue));
+    return storage.subscribe?.(key, setAtom, initialValue);
+  };
+  const anAtom = atom((get) => get(baseAtom), (get, set, update) => {
+    const nextValue = typeof update === "function" ? update(get(baseAtom)) : update;
+    if (nextValue === RESET) {
+      set(baseAtom, initialValue);
+      return storage.removeItem(key);
+    }
+    if (isPromiseLike(nextValue)) {
+      return nextValue.then((resolvedValue) => {
+        set(baseAtom, resolvedValue);
+        return storage.setItem(key, resolvedValue);
+      });
+    }
+    set(baseAtom, nextValue);
+    return storage.setItem(key, nextValue);
+  });
+  return anAtom;
+}
+
+// node_modules/jotai/dist/vanilla/utils/unwrap.js
+var getCached2 = (c, m, k) => (m.has(k) ? m : m.set(k, c())).get(k);
+var cache12 = /* @__PURE__ */ new WeakMap();
+var memo2 = (create, dep1, dep2) => {
+  const cache2 = getCached2(() => /* @__PURE__ */ new WeakMap(), cache12, dep1);
+  return getCached2(create, cache2, dep2);
+};
+var isPromiseLike2 = (p) => typeof p?.then === "function";
+var defaultFallback = () => void 0;
+function unwrap(anAtom, fallback = defaultFallback) {
+  return memo2(() => {
+    const promiseErrorCache = /* @__PURE__ */ new WeakMap();
+    const promiseResultCache = /* @__PURE__ */ new WeakMap();
+    const refreshAtom = atom(0);
+    const triggerRefreshAtom = atom([]);
+    triggerRefreshAtom.INTERNAL_onInit = (store) => {
+      store.set(triggerRefreshAtom, [
+        () => store.set(refreshAtom, (c) => c + 1)
+      ]);
+    };
+    if (process.env.NODE_ENV !== "production") {
+      refreshAtom.debugPrivate = true;
+      triggerRefreshAtom.debugPrivate = true;
+    }
+    const promiseAndValueAtom = atom((get) => {
+      get(refreshAtom);
+      let prev;
+      try {
+        prev = get(promiseAndValueAtom);
+      } catch {
+      }
+      const promise = get(anAtom);
+      if (!isPromiseLike2(promise)) {
+        return { v: promise };
+      }
+      if (promise !== prev?.p) {
+        promise.then((v) => {
+          promiseResultCache.set(promise, v);
+          const [triggerRefresh] = get(triggerRefreshAtom);
+          triggerRefresh();
+        }, (e) => {
+          promiseErrorCache.set(promise, e);
+          const [triggerRefresh] = get(triggerRefreshAtom);
+          triggerRefresh();
+        });
+      }
+      if (promiseErrorCache.has(promise)) {
+        if (prev && "e" in prev && prev.p === promise) {
+          return prev;
+        }
+        const e = promiseErrorCache.get(promise);
+        if (prev && "v" in prev) {
+          return { p: promise, e, v: prev.v };
+        }
+        return { p: promise, e };
+      }
+      if (promiseResultCache.has(promise)) {
+        return {
+          p: promise,
+          v: promiseResultCache.get(promise)
+        };
+      }
+      if (prev && "v" in prev) {
+        return { p: promise, f: fallback(prev.v), v: prev.v };
+      }
+      return { p: promise, f: fallback() };
+    });
+    promiseAndValueAtom.init = void 0;
+    if (process.env.NODE_ENV !== "production") {
+      promiseAndValueAtom.debugPrivate = true;
+    }
+    return atom((get) => {
+      const state = get(promiseAndValueAtom);
+      if ("e" in state) {
+        throw state.e;
+      }
+      if ("f" in state) {
+        return state.f;
+      }
+      return state.v;
+    }, (_get, set, ...args) => set(anAtom, ...args));
+  }, anAtom, fallback);
+}
+
+export {
+  selectAtom,
+  atomWithStorage,
+  unwrap
+};

package/dist/chunks/{chunk-HFBZMKIN.js → chunk-XMOVGDFI.js}

@@ -1,7 +1,7 @@
 // package.json with { type: 'json' }
 var package_default = {
   name: "alinea",
-  version: "2.0.0-preview.3",
+  version: "2.0.0-preview.4",
   description: "Headless git-based CMS",
   repository: "github:alineacms/alinea",
   license: "MIT",

package/dist/cli/Serve.js

@@ -1,6 +1,6 @@
 import {
   package_default
-} from "../chunks/chunk-HFBZMKIN.js";
+} from "../chunks/chunk-XMOVGDFI.js";
 import "../chunks/chunk-CQ52GEHY.js";
 
 // src/cli/Serve.ts

package/dist/cli/bin.js

@@ -220,7 +220,7 @@ var lib_default2 = (e, t2) => new o(e, t2);
 // package.json
 var package_default = {
   name: "alinea",
-  version: "2.0.0-preview.3",
+  version: "2.0.0-preview.4",
   description: "Headless git-based CMS",
   repository: "github:alineacms/alinea",
   license: "MIT",

package/dist/cli/serve/LocalAuth.js

@@ -9,7 +9,7 @@ var LocalAuth = class {
     this.#user = user;
   }
   async authenticate() {
-    return new Response("ok");
+    throw new Error("Local authentication is not supported");
   }
   async verify(request) {
     const ctx = this.#context;

package/dist/cloud/AuthResult.d.ts

@@ -1,3 +1,4 @@
+import type { BackendCapabilities } from 'alinea/core/Connection';
 import type { User } from 'alinea/core/User';
 export declare enum AuthResultType {
     Authenticated = 0,
@@ -8,6 +9,7 @@ export declare enum AuthResultType {
 export type AuthResult = {
     type: AuthResultType.Authenticated;
     user: User;
+    capabilities?: BackendCapabilities;
 } | {
     type: AuthResultType.UnAuthenticated;
     redirect: string;

package/dist/cloud/CloudHandshake.d.ts

@@ -0,0 +1,7 @@
+interface VerifyCloudHandshakeOptions {
+    clientId: string;
+    handshakeId: string;
+    origin: string;
+}
+export declare function verifyCloudHandshake(token: string, options: VerifyCloudHandshakeOptions): Promise<void>;
+export {};

package/dist/cloud/CloudHandshake.js

@@ -0,0 +1,64 @@
+import "../chunks/chunk-CQ52GEHY.js";
+
+// src/cloud/CloudHandshake.ts
+import { decode, verify } from "alinea/core/util/JWT";
+import { isRecord } from "alinea/core/util/Objects";
+import { cloudConfig } from "./CloudConfig.js";
+var keysPromise;
+var keysExpireAt = 0;
+var lastForcedRefreshAt = 0;
+var keyCacheLifetime = 5 * 60 * 1e3;
+var forcedRefreshInterval = 60 * 1e3;
+async function verifyCloudHandshake(token, options) {
+  const { header } = decode(token);
+  if (header.alg !== "RS256" || typeof header.kid !== "string")
+    throw new Error("Invalid handshake token header");
+  let key = (await cloudKeys()).find((key2) => key2.kid === header.kid);
+  if (!key) {
+    key = (await refreshCloudKeys()).find((key2) => key2.kid === header.kid);
+  }
+  if (!key) throw new Error("Unknown handshake signing key");
+  const payload = await verify(token, key, { algorithms: ["RS256"] });
+  if (!isRecord(payload) || payload.purpose !== "handshake" || payload.handshake_id !== options.handshakeId || payload.aud !== options.clientId || payload.iss !== normalizedCloudUrl() || payload.origin !== options.origin || typeof payload.project !== "string" || typeof payload.iat !== "number" || typeof payload.exp !== "number") {
+    throw new Error("Invalid handshake token claims");
+  }
+}
+function cloudKeys() {
+  if (keysPromise && (keysExpireAt === 0 || Date.now() < keysExpireAt))
+    return keysPromise;
+  return loadCloudKeys();
+}
+function refreshCloudKeys() {
+  const now = Date.now();
+  if (keysPromise && keysExpireAt === 0) return keysPromise;
+  if (keysPromise && now - lastForcedRefreshAt < forcedRefreshInterval)
+    return keysPromise;
+  lastForcedRefreshAt = now;
+  return loadCloudKeys();
+}
+function loadCloudKeys() {
+  keysExpireAt = 0;
+  keysPromise = fetch(cloudConfig.jwks).then(async (response) => {
+    if (!response.ok)
+      throw new Error(`Could not load handshake keys: ${response.status}`);
+    const body = await response.json();
+    if (!isRecord(body) || !Array.isArray(body.keys))
+      throw new Error("Invalid handshake key response");
+    keysExpireAt = Date.now() + keyCacheLifetime;
+    return body.keys.filter(isCloudKey);
+  }).catch((cause) => {
+    keysPromise = void 0;
+    keysExpireAt = 0;
+    throw cause;
+  });
+  return keysPromise;
+}
+function isCloudKey(value) {
+  return isRecord(value) && typeof value.kid === "string";
+}
+function normalizedCloudUrl() {
+  return cloudConfig.url.replace(/\/$/, "");
+}
+export {
+  verifyCloudHandshake
+};

package/dist/cloud/CloudRemote.d.ts

@@ -10,12 +10,15 @@ import type { User, UserInput } from 'alinea/core/User';
 export declare class CloudRemote extends OAuth2 implements RemoteConnection {
     #private;
     constructor(context: RequestContext, config: Config);
+    capabilities(): Promise<{
+        users: boolean;
+    }>;
     getTreeIfDifferent(sha: string): Promise<ReadonlyTree | undefined>;
     getBlobs(shas: ReadonlyArray<string>, options?: GetBlobsOptions): AsyncGenerator<[sha: string, blob: Uint8Array]>;
     write(request: CommitRequest): Promise<{
         sha: string;
     }>;
-    authenticate(request: Request, options?: AuthOptions): Promise<globalThis.Response>;
+    authenticate(request: Request, options: AuthOptions): Promise<globalThis.Response>;
     prepareUpload(file: string, metadata?: UploadMetadata): Promise<{
         entryId: string;
         location: string;

package/dist/cloud/CloudRemote.js

@@ -1,6 +1,6 @@
 import {
   package_default
-} from "../chunks/chunk-HFBZMKIN.js";
+} from "../chunks/chunk-XMOVGDFI.js";
 import "../chunks/chunk-CQ52GEHY.js";
 
 // src/cloud/CloudRemote.ts
@@ -20,6 +20,7 @@ import { Workspace } from "alinea/core/Workspace";
 import { Response } from "@alinea/iso";
 import { AuthResultType } from "./AuthResult.js";
 import { cloudConfig } from "./CloudConfig.js";
+import { verifyCloudHandshake } from "./CloudHandshake.js";
 var CloudRemote = class extends OAuth2 {
   #context;
   #config;
@@ -42,6 +43,9 @@ var CloudRemote = class extends OAuth2 {
     this.#context = context;
     this.#config = config;
   }
+  async capabilities() {
+    return { users: false };
+  }
   async getTreeIfDifferent(sha) {
     const ctx = this.#context;
     return parseOutcome(
@@ -122,13 +126,27 @@ var CloudRemote = class extends OAuth2 {
       // The cloud server will request a handshake confirmation on this route
       case AuthAction.Handshake: {
         const handShakeId = url.searchParams.get("handshake_id");
-        if (!handShakeId)
+        const handshakeToken = url.searchParams.get("handshake_token");
+        if (!handShakeId || !handshakeToken)
           throw new HttpError(
             400,
-            "Provide a valid handshake id to initiate handshake"
+            "Provide valid handshake credentials to initiate handshake"
           );
+        const clientId = ctx.apiKey.split("_")[1];
+        if (!clientId)
+          throw new HttpError(401, "A Cloud API key is required for handshake");
+        try {
+          await verifyCloudHandshake(handshakeToken, {
+            clientId,
+            handshakeId: handShakeId,
+            origin: new URL(ctx.handlerUrl).origin
+          });
+        } catch (cause) {
+          throw new HttpError(401, "Invalid handshake token", { cause });
+        }
         const body = {
           handshake_id: handShakeId,
+          handshake_token: handshakeToken,
           status: {
             version: package_default.version,
             roles: entries(this.#config.roles ?? {}).map(([name, role]) => {

package/dist/components/Calendar.js

@@ -27,17 +27,17 @@ import {
 
 // src/components/Calendar.module.css
 var Calendar_default = {
-  "Calendar-cell": "alinea-Calendar-cell",
-  "CalendarCell": "alinea-Calendar-cell",
+  "Calendar-button": "alinea-Calendar-button",
+  "CalendarButton": "alinea-Calendar-button",
   "Calendar-grid": "alinea-Calendar-grid",
   "CalendarGrid": "alinea-Calendar-grid",
+  "Calendar-cell": "alinea-Calendar-cell",
+  "CalendarCell": "alinea-Calendar-cell",
+  "Calendar": "alinea-Calendar",
   "Calendar-header": "alinea-Calendar-header",
   "CalendarHeader": "alinea-Calendar-header",
-  "Calendar-button": "alinea-Calendar-button",
-  "CalendarButton": "alinea-Calendar-button",
   "Calendar-heading": "alinea-Calendar-heading",
-  "CalendarHeading": "alinea-Calendar-heading",
-  "Calendar": "alinea-Calendar"
+  "CalendarHeading": "alinea-Calendar-heading"
 };
 
 // src/components/Calendar.tsx

package/dist/components/Checkbox.js

@@ -16,11 +16,11 @@ import "../chunks/chunk-CQ52GEHY.js";
 
 // src/components/Checkbox.module.css
 var Checkbox_default = {
+  "Checkbox": "alinea-Checkbox",
   "Checkbox-box": "alinea-Checkbox-box",
   "CheckboxBox": "alinea-Checkbox-box",
   "Checkbox-mark": "alinea-Checkbox-mark",
-  "CheckboxMark": "alinea-Checkbox-mark",
-  "Checkbox": "alinea-Checkbox"
+  "CheckboxMark": "alinea-Checkbox-mark"
 };
 
 // src/components/Checkbox.tsx

package/dist/components/ComboBox.js

@@ -29,24 +29,24 @@ import {
 
 // src/components/ComboBox.module.css
 var ComboBox_default = {
-  "ComboBoxItem": "alinea-ComboBoxItem",
-  "ComboBoxTrigger-button-arrow": "alinea-ComboBoxTrigger-button-arrow",
-  "ComboBoxTriggerButtonArrow": "alinea-ComboBoxTrigger-button-arrow",
-  "ComboBoxTrigger-button": "alinea-ComboBoxTrigger-button",
-  "ComboBoxTriggerButton": "alinea-ComboBoxTrigger-button",
-  "ComboBoxTrigger": "alinea-ComboBoxTrigger",
-  "ComboBoxTrigger-actions": "alinea-ComboBoxTrigger-actions",
-  "ComboBoxTriggerActions": "alinea-ComboBoxTrigger-actions",
   "ComboBoxPopover-listbox": "alinea-ComboBoxPopover-listbox",
   "ComboBoxPopoverListbox": "alinea-ComboBoxPopover-listbox",
-  "ComboBoxClear": "alinea-ComboBoxClear",
-  "ComboBoxTrigger-input": "alinea-ComboBoxTrigger-input",
-  "ComboBoxTriggerInput": "alinea-ComboBoxTrigger-input",
   "ComboBoxItem-check": "alinea-ComboBoxItem-check",
   "ComboBoxItemCheck": "alinea-ComboBoxItem-check",
+  "ComboBoxTrigger-actions": "alinea-ComboBoxTrigger-actions",
+  "ComboBoxTriggerActions": "alinea-ComboBoxTrigger-actions",
+  "ComboBox": "alinea-ComboBox",
   "ComboBoxTrigger-button-value": "alinea-ComboBoxTrigger-button-value",
   "ComboBoxTriggerButtonValue": "alinea-ComboBoxTrigger-button-value",
-  "ComboBox": "alinea-ComboBox"
+  "ComboBoxTrigger-button-arrow": "alinea-ComboBoxTrigger-button-arrow",
+  "ComboBoxTriggerButtonArrow": "alinea-ComboBoxTrigger-button-arrow",
+  "ComboBoxTrigger": "alinea-ComboBoxTrigger",
+  "ComboBoxClear": "alinea-ComboBoxClear",
+  "ComboBoxItem": "alinea-ComboBoxItem",
+  "ComboBoxTrigger-button": "alinea-ComboBoxTrigger-button",
+  "ComboBoxTriggerButton": "alinea-ComboBoxTrigger-button",
+  "ComboBoxTrigger-input": "alinea-ComboBoxTrigger-input",
+  "ComboBoxTriggerInput": "alinea-ComboBoxTrigger-input"
 };
 
 // src/components/ComboBox.tsx