alinea 1.7.0 → 2.0.0-preview.0

package/dist/dashboard/atoms/ErrorAtoms.js

@@ -1,18 +0,0 @@
-import {
-  atom
-} from "../../chunks/chunk-WJ67RR7S.js";
-import "../../chunks/chunk-NZLE2WMY.js";
-
-// src/dashboard/atoms/ErrorAtoms.ts
-var errorMessageAtom = atom(null);
-var errorAtom = atom(
-  (get) => get(errorMessageAtom),
-  (get, set, message, cause) => {
-    set(errorMessageAtom, message);
-    if (cause) console.error(cause);
-  }
-);
-export {
-  errorAtom,
-  errorMessageAtom
-};

package/dist/dashboard/atoms/FormAtoms.d.ts

@@ -1,56 +0,0 @@
-import { Field } from 'alinea/core/Field';
-import { Type } from 'alinea/core/Type';
-import { type Atom } from 'jotai';
-import { type PropsWithChildren } from 'react';
-import * as Y from 'yjs';
-export interface FieldInfo<StoredValue = any, QueryValue = any, Mutator = any, Options = any> {
-    key: string;
-    field: Field<StoredValue, QueryValue, Mutator, Options>;
-    value: Atom<StoredValue>;
-    options: Atom<Options | Promise<Options>>;
-    error: Atom<boolean | string | undefined>;
-    mutator: Mutator;
-}
-export declare class FormAtoms<T = any> {
-    type: Type<T>;
-    container: Y.Map<any>;
-    path: string;
-    options: {
-        parent?: FormAtoms;
-        readOnly?: boolean;
-    };
-    private fields;
-    private errorMap;
-    errors: import("jotai").WritableAtom<Map<string, {
-        field: Field;
-        error: boolean | string;
-    }>, [path: string, field: Field<any, any, any, any>, error: string | boolean | undefined], void>;
-    hasErrors: Atom<boolean>;
-    constructor(type: Type<T>, container: Y.Map<any>, path?: string, options?: {
-        parent?: FormAtoms;
-        readOnly?: boolean;
-    });
-    data(): Type.Infer<T>;
-    private getter;
-    private valueAtom;
-    fieldByKey(key: string): Field;
-    keyOf(field: Field): string;
-    fieldInfo<StoredValue, QueryValue, Mutator, Options>(field: Field<StoredValue, QueryValue, Mutator, Options>): FieldInfo<StoredValue, QueryValue, Mutator, Options>;
-}
-export interface UseFormOptions<T> {
-    doc?: Y.Doc;
-    initialValue?: Partial<Type.Infer<T>>;
-}
-export declare function useForm<T>(type: Type<T>, options?: UseFormOptions<T>): FormAtoms<T>;
-export declare function useFormContext(): FormAtoms<any>;
-export interface FieldAtomsProviderProps {
-    form: FormAtoms;
-}
-export declare function FormProvider({ children, form }: PropsWithChildren<FieldAtomsProviderProps>): import("react/jsx-runtime").JSX.Element;
-export interface FormRowProps {
-    field: Field;
-    rowId?: string;
-    type: Type;
-    readOnly?: boolean;
-}
-export declare function FormRow({ children, field, type, rowId, readOnly }: PropsWithChildren<FormRowProps>): import("react/jsx-runtime").JSX.Element;

package/dist/dashboard/atoms/FormAtoms.js

@@ -1,189 +0,0 @@
-import {
-  unwrap
-} from "../../chunks/chunk-WDCPVJJC.js";
-import {
-  atom
-} from "../../chunks/chunk-WJ67RR7S.js";
-import {
-  Doc
-} from "../../chunks/chunk-QUIANN6B.js";
-import "../../chunks/chunk-AJJSW27C.js";
-import "../../chunks/chunk-NZLE2WMY.js";
-
-// src/dashboard/atoms/FormAtoms.tsx
-import { Field } from "alinea/core/Field";
-import { Type } from "alinea/core/Type";
-import { entries } from "alinea/core/util/Objects";
-import { createContext, useContext, useMemo } from "react";
-import { DOC_KEY, applyEntryData } from "alinea/core/Doc";
-import { Section } from "alinea/core/Section";
-import {
-  optionTrackerOf,
-  valueTrackerOf
-} from "alinea/core/Tracker";
-import { jsx } from "react/jsx-runtime";
-var FormAtoms = class {
-  constructor(type, container, path = "", options = {}) {
-    this.type = type;
-    this.container = container;
-    this.path = path;
-    this.options = options;
-    const readOnly = options.readOnly;
-    const forcedOptions = readOnly === true ? { readOnly } : {};
-    container.doc.transact(() => {
-      for (const section of Type.sections(type)) {
-        for (const [key, field] of entries(Section.fields(section))) {
-          const ref = Field.ref(field);
-          const shape = Field.shape(field);
-          const defaultOptions = { ...Field.options(field), ...forcedOptions };
-          const optionsTracker = optionTrackerOf(field);
-          shape.init(container, key);
-          const mutator = shape.mutator(container, key);
-          const options2 = optionsTracker ? unwrap(
-            atom((get) => {
-              const tracked = optionsTracker(this.getter(get));
-              if (tracked instanceof Promise)
-                return tracked.then((partial) => {
-                  return { ...defaultOptions, ...partial, ...forcedOptions };
-                });
-              return { ...defaultOptions, ...tracked, ...forcedOptions };
-            }),
-            (prev) => prev ?? defaultOptions
-          ) : atom(defaultOptions);
-          const valueTracker = valueTrackerOf(field);
-          const value = this.valueAtom(field, key, valueTracker);
-          const error = atom((get) => {
-            const { validate, required } = get(options2);
-            if (validate) {
-              const res = validate(get(value));
-              if (typeof res === "boolean") return !res;
-              return res;
-            }
-            if (required) {
-              const current = get(value);
-              if (current === void 0 || current === null) return true;
-              if (typeof current === "string" && current === "") return true;
-              if (Array.isArray(current) && current.length === 0) return true;
-            }
-          });
-          this.fields.set(ref, {
-            key,
-            field,
-            value,
-            mutator,
-            error,
-            options: options2
-          });
-        }
-      }
-    }, "self");
-  }
-  fields = /* @__PURE__ */ new Map();
-  errorMap = atom(
-    /* @__PURE__ */ new Map()
-  );
-  errors = atom(
-    (get) => get(this.errorMap),
-    (get, set, path, field, error) => {
-      const current = get(this.errorMap);
-      if (!error && !current.has(path)) return;
-      const errors = new Map(current);
-      if (error) errors.set(path, { field, error });
-      else errors.delete(path);
-      set(this.errorMap, errors);
-      if (this.options.parent)
-        set(this.options.parent.errors, path, field, error);
-    }
-  );
-  hasErrors = atom((get) => get(this.errorMap).size > 0);
-  data() {
-    return Type.shape(this.type).fromY(this.container);
-  }
-  getter = (get) => (field) => {
-    const info = this.fieldInfo(field);
-    if (!info) throw new Error(`Field not found: ${Field.label(field)}`);
-    return get(info.value);
-  };
-  valueAtom(field, key, tracker) {
-    const shape = Field.shape(field);
-    const revision = atom(0);
-    revision.onMount = (setAtom) => {
-      const onChange = () => setAtom((x) => x + 1);
-      const watch = shape.watch(this.container, key);
-      onChange();
-      return watch(onChange);
-    };
-    return atom((g) => {
-      g(revision);
-      const current = shape.fromY(this.container.get(key));
-      const next = tracker ? tracker(this.getter(g)) : current;
-      if (tracker && next !== current) shape.applyY(next, this.container, key);
-      return next;
-    });
-  }
-  fieldByKey(key) {
-    for (const info of this.fields.values())
-      if (info.key === key) return info.field;
-    throw new Error(`Field not found: "${key}"`);
-  }
-  keyOf(field) {
-    return this.fieldInfo(field).key;
-  }
-  fieldInfo(field) {
-    const res = this.fields.get(Field.ref(field));
-    const label = Field.label(field);
-    if (!res) {
-      if (this.options.parent) return this.options.parent.fieldInfo(field);
-      throw new Error(`Field not found: ${label}`);
-    }
-    return res;
-  }
-};
-var formAtomsContext = createContext(void 0);
-function useForm(type, options = {}) {
-  return useMemo(() => {
-    const doc = options.doc ?? new Doc();
-    if (options.initialValue) {
-      applyEntryData(doc, type, { data: options.initialValue });
-    }
-    return new FormAtoms(type, doc.getMap(DOC_KEY));
-  }, [type, options.doc]);
-}
-function useFormContext() {
-  const formAtoms = useContext(formAtomsContext);
-  if (!formAtoms) throw new Error("FormAtoms is not provided");
-  return formAtoms;
-}
-function FormProvider({
-  children,
-  form
-}) {
-  return /* @__PURE__ */ jsx(formAtomsContext.Provider, { value: form, children });
-}
-function FormRow({
-  children,
-  field,
-  type,
-  rowId,
-  readOnly
-}) {
-  const form = useFormContext();
-  const rowForm = useMemo(() => {
-    const key = form.keyOf(field);
-    const inner = form.container.get(key);
-    const row = rowId ? inner.get(rowId) : inner;
-    const path = `${form.path}.${key}${rowId ? `[${rowId}]` : ""}`;
-    return new FormAtoms(type, row, path, {
-      readOnly,
-      parent: form
-    });
-  }, [form, rowId, readOnly]);
-  return /* @__PURE__ */ jsx(FormProvider, { form: rowForm, children });
-}
-export {
-  FormAtoms,
-  FormProvider,
-  FormRow,
-  useForm,
-  useFormContext
-};

package/dist/dashboard/atoms/LocationAtoms.d.ts

@@ -1,25 +0,0 @@
-export declare const hashAtom: import("jotai").WritableAtom<string, [hash: string], void> & {
-    init: string;
-};
-export declare const locationAtom: import("jotai").WritableAtom<URL, [url: string], void>;
-interface Matcher {
-    keys: Array<string>;
-    pattern: RegExp;
-}
-export declare function createParams(matcher: Matcher, match: RegExpExecArray): Record<string, string>;
-interface MatchOptions {
-    route: string;
-    loose?: boolean;
-}
-export declare const matchAtoms: import("jotai/vanilla/utils/atomFamily").AtomFamily<MatchOptions, import("jotai").Atom<Record<string, string> | undefined>>;
-export declare function useMatch(route: string, loose?: boolean): [Record<string, string> | undefined, never];
-export declare const useHash: () => [string, (hash: string) => void];
-export declare function useLocation(): URL;
-export declare function useSearchParams(): URLSearchParams;
-export declare function useNavigate(): (url: string) => void;
-export declare function link(url: string | undefined): {
-    href: string;
-} | {
-    href?: undefined;
-};
-export {};

package/dist/dashboard/atoms/LocationAtoms.js

@@ -1,104 +0,0 @@
-import {
-  useAtom,
-  useAtomValue,
-  useSetAtom
-} from "../../chunks/chunk-TOJF2G3X.js";
-import {
-  atomFamily
-} from "../../chunks/chunk-WDCPVJJC.js";
-import {
-  atom
-} from "../../chunks/chunk-WJ67RR7S.js";
-import {
-  parse
-} from "../../chunks/chunk-467JA2PB.js";
-import "../../chunks/chunk-NZLE2WMY.js";
-
-// src/dashboard/atoms/LocationAtoms.ts
-import { values } from "alinea/core/util/Objects";
-var browser = {
-  get location() {
-    return globalThis?.location ?? { hash: "" };
-  }
-};
-var hashAtom = atom(
-  browser.location.hash,
-  (get, set, hash) => {
-    if (get(hashAtom) !== hash) browser.location.hash = hash;
-    set(hashAtom, hash);
-  }
-);
-hashAtom.onMount = (set) => {
-  const listener = () => set(browser.location.hash);
-  window.addEventListener("hashchange", listener);
-  return () => window.removeEventListener("hashchange", listener);
-};
-var locationAtom = atom(
-  (get) => {
-    const hash = get(hashAtom);
-    const path = hash.slice(1) || "/";
-    return new URL(path, browser.location.href);
-  },
-  (get, set, url) => {
-    const hash = `#${url}`;
-    set(hashAtom, hash);
-  }
-);
-function createParams(matcher, match) {
-  const params = {};
-  if (matcher.keys)
-    for (let i = 0; i < matcher.keys.length; i++)
-      params[matcher.keys[i]] = match[i + 1];
-  return params;
-}
-var matchAtoms = atomFamily(
-  ({ route, loose }) => {
-    let current;
-    const matcher = parse(route, loose);
-    return atom((get) => {
-      const location = get(locationAtom);
-      const match = matcher.pattern.exec(location.pathname);
-      if (match === null) return void 0;
-      const result = createParams(matcher, match);
-      if (current) {
-        const resultValues = values(result);
-        const currentValues = values(current);
-        if (resultValues.every((v, i) => v === currentValues[i])) return current;
-      }
-      return current = result;
-    });
-  },
-  (a, b) => a.route === b.route && a.loose === b.loose
-);
-function useMatch(route, loose) {
-  return useAtom(matchAtoms({ route, loose }));
-}
-var useHash = () => useAtom(hashAtom);
-function useLocation() {
-  return useAtomValue(locationAtom);
-}
-function useSearchParams() {
-  const location = useLocation();
-  return new URLSearchParams(location.search);
-}
-function useNavigate() {
-  const setLocation = useSetAtom(locationAtom);
-  return function navigate(url) {
-    setLocation(url);
-  };
-}
-function link(url) {
-  return typeof url === "string" ? { href: `#${url}` } : {};
-}
-export {
-  createParams,
-  hashAtom,
-  link,
-  locationAtom,
-  matchAtoms,
-  useHash,
-  useLocation,
-  useMatch,
-  useNavigate,
-  useSearchParams
-};

package/dist/dashboard/atoms/NavigationAtoms.d.ts

@@ -1,38 +0,0 @@
-import { type EntryLocation } from '../DashboardNav.js';
-export declare const workspaceAtom: import("jotai").Atom<{
-    source: string;
-    mediaDir?: string;
-    icon?: import("react").ComponentType;
-    preview?: import("alinea/core/Preview.js").Preview;
-    roots: import("alinea/core/Workspace").RootsDefinition;
-    label: string;
-    color: string;
-    name: string;
-}>;
-export declare const rootAtom: import("jotai").Atom<{
-    name: string;
-    contains?: Array<string | import("alinea").Type>;
-    orderChildrenBy?: import("alinea/core/OrderBy.js").OrderBy | Array<import("alinea/core/OrderBy.js").OrderBy>;
-    icon?: import("react").ComponentType;
-    i18n?: import("alinea/core/Root").RootI18n;
-    view?: import("alinea/core/View.js").View<{
-        root: import("alinea/core/Root").RootData;
-    }>;
-    isMediaRoot?: boolean;
-    preview?: import("alinea/core/Preview.js").Preview;
-    label: string;
-}>;
-export declare const preferredLanguageAtom: import("jotai").WritableAtom<string | null, [string | typeof import("jotai/utils").RESET | ((prev: string | null) => string | typeof import("jotai/utils").RESET | null) | null], void>;
-export declare const localeAtom: import("jotai").Atom<string | null>;
-export declare const entryLocationAtom: import("jotai").Atom<EntryLocation>;
-export declare const navAtom: import("jotai").Atom<{
-    matchEntry: '/entry/*';
-    matchEntryId: '/:action/:workspace/:root?/:id?';
-    matchWorkspace: '/:action/:workspace';
-    matchRoot: '/:action/:workspace/:root';
-    root: ({ id, ...location }: EntryLocation) => string;
-    entry: (location: EntryLocation) => string;
-    draft: (location: EntryLocation) => string;
-    create: (location: EntryLocation) => string;
-}>;
-export declare const usePreferredLanguage: () => [string | null, (args_0: string | typeof import("jotai/utils").RESET | ((prev: string | null) => string | typeof import("jotai/utils").RESET | null) | null) => void];

package/dist/dashboard/atoms/NavigationAtoms.js

@@ -1,124 +0,0 @@
-import {
-  useAtom
-} from "../../chunks/chunk-TOJF2G3X.js";
-import {
-  atomWithStorage
-} from "../../chunks/chunk-WDCPVJJC.js";
-import {
-  atom
-} from "../../chunks/chunk-WJ67RR7S.js";
-import "../../chunks/chunk-NZLE2WMY.js";
-
-// src/dashboard/atoms/NavigationAtoms.tsx
-import { ErrorCode, HttpError } from "alinea/core/HttpError";
-import { Root } from "alinea/core/Root";
-import { Workspace } from "alinea/core/Workspace";
-import { keys } from "alinea/core/util/Objects";
-import { dashboardNav, navMatchers } from "../DashboardNav.js";
-import { configAtom } from "./DashboardAtoms.js";
-import { matchAtoms } from "./LocationAtoms.js";
-import { policyAtom } from "./PolicyAtom.js";
-import { workspacePreferenceAtom } from "./PreferencesAtoms.js";
-var workspaceNameAtom = atom((get) => {
-  const policy = get(policyAtom);
-  const config = get(configAtom);
-  const match = get(
-    matchAtoms({ route: navMatchers.matchWorkspace, loose: true })
-  );
-  const workspacePreference = get(workspacePreferenceAtom);
-  const params = match ?? {};
-  const requested = [
-    params.workspace,
-    workspacePreference,
-    ...keys(config.workspaces)
-  ];
-  for (const name of requested) {
-    if (name && config.workspaces[name]) {
-      const canRead = policy.canRead({ workspace: name });
-      if (canRead) return name;
-    }
-  }
-  throw new HttpError(
-    ErrorCode.Unauthorized,
-    `You don't have access to any workspaces`
-  );
-});
-var workspaceAtom = atom((get) => {
-  const config = get(configAtom);
-  const name = get(workspaceNameAtom);
-  return { name, ...Workspace.data(config.workspaces[name]) };
-});
-function parseRootPath(path) {
-  return path.split(":");
-}
-var rootNameAtom = atom((get) => {
-  const policy = get(policyAtom);
-  const workspace = get(workspaceAtom);
-  const match = get(matchAtoms({ route: navMatchers.matchRoot, loose: true }));
-  const params = match ?? {};
-  const requestedRoot = params.root ? parseRootPath(params.root)[0] : void 0;
-  const requested = [requestedRoot, ...keys(workspace.roots)];
-  for (const name of requested) {
-    if (name && workspace.roots[name]) {
-      const canRead = policy.canRead({ workspace: workspace.name, root: name });
-      if (canRead) return name;
-    }
-  }
-  throw new Error("No root found");
-});
-var rootAtom = atom((get) => {
-  const config = get(configAtom);
-  const workspace = get(workspaceAtom);
-  const name = get(rootNameAtom);
-  const root = workspace.roots[name];
-  if (!root) throw new Error("No root found");
-  return { name, ...Root.data(config.workspaces[workspace.name][name]) };
-});
-var preferredLanguageAtom = atomWithStorage(
-  "@alinea/locale",
-  null
-);
-var localeAtom = atom((get) => {
-  const workspace = get(workspaceAtom);
-  const root = get(rootAtom);
-  const config = get(configAtom);
-  const { i18n } = root;
-  if (!i18n) return null;
-  const match = get(matchAtoms({ route: navMatchers.matchRoot, loose: true }));
-  const params = match ?? {};
-  const { root: rootKey } = params;
-  if (rootKey) {
-    const fromUrl = parseRootPath(rootKey)[1];
-    if (fromUrl && i18n.locales.includes(fromUrl)) return fromUrl;
-  }
-  const preferredLanguage = get(preferredLanguageAtom);
-  if (preferredLanguage && i18n.locales.includes(preferredLanguage))
-    return preferredLanguage;
-  return Root.defaultLocale(config.workspaces[workspace.name][root.name]) ?? null;
-});
-var entryLocationAtom = atom((get) => {
-  const match = get(matchAtoms({ route: navMatchers.matchEntryId }));
-  const [root, locale] = parseRootPath(match?.root ?? "");
-  const params = {
-    ...match,
-    locale
-  };
-  if (root) params.root = root;
-  return params || void 0;
-});
-var navAtom = atom((get) => {
-  const { name: workspace } = get(workspaceAtom);
-  const { name: root } = get(rootAtom);
-  const locale = get(localeAtom);
-  return dashboardNav({ workspace, root, locale });
-});
-var usePreferredLanguage = () => useAtom(preferredLanguageAtom);
-export {
-  entryLocationAtom,
-  localeAtom,
-  navAtom,
-  preferredLanguageAtom,
-  rootAtom,
-  usePreferredLanguage,
-  workspaceAtom
-};

package/dist/dashboard/atoms/PolicyAtom.d.ts

@@ -1,6 +0,0 @@
-import type { Policy } from 'alinea/core/Role';
-import { type Atom } from 'jotai';
-export declare const policyTrigger: Atom<Promise<Policy>> & {
-    current: Atom<Policy | undefined>;
-};
-export declare const policyAtom: Atom<Policy>;

package/dist/dashboard/atoms/PolicyAtom.js

@@ -1,29 +0,0 @@
-import {
-  atom
-} from "../../chunks/chunk-WJ67RR7S.js";
-import "../../chunks/chunk-NZLE2WMY.js";
-
-// src/dashboard/atoms/PolicyAtom.ts
-import { assert } from "alinea/core/util/Assert";
-import { sessionAtom } from "../atoms/DashboardAtoms.js";
-import { dbAtom } from "../atoms/DbAtoms.js";
-import { keepPreviousData } from "../util/KeepPreviousData.js";
-var policyTrigger = keepPreviousData(
-  atom(async (get) => {
-    const session = get(sessionAtom);
-    assert(session);
-    const db = get(dbAtom);
-    const policy = await db.createPolicy(session.user.roles);
-    return policy;
-  }),
-  {
-    compare(a, b) {
-      return a.equals(b);
-    }
-  }
-);
-var policyAtom = policyTrigger.current;
-export {
-  policyAtom,
-  policyTrigger
-};

package/dist/dashboard/atoms/PreferencesAtoms.d.ts

@@ -1,16 +0,0 @@
-export type ColorScheme = 'light' | 'dark' | undefined;
-export type Language = 'en' | undefined;
-export interface Preferences {
-    scheme: ColorScheme;
-    workspace: string | undefined;
-    size: number;
-    language: Language;
-}
-export declare const preferencesAtom: import("jotai").WritableAtom<Preferences, [typeof import("jotai/utils").RESET | Preferences | ((prev: Preferences) => typeof import("jotai/utils").RESET | Preferences)], void>;
-export declare const schemePreferenceAtom: import("jotai").WritableAtom<ColorScheme, [scheme: ColorScheme], void>;
-export declare const toggleSchemePreferenceAtom: import("jotai").WritableAtom<null, [], void> & {
-    init: null;
-};
-export declare const workspacePreferenceAtom: import("jotai").WritableAtom<string | undefined, [workspace: string | undefined], void>;
-export declare const sizePreferenceAtom: import("jotai").WritableAtom<number, [size: number], void>;
-export declare const languagePreferenceAtom: import("jotai").WritableAtom<Language, [language: Language], void>;

package/dist/dashboard/atoms/PreferencesAtoms.js

@@ -1,53 +0,0 @@
-import {
-  atomWithStorage
-} from "../../chunks/chunk-WDCPVJJC.js";
-import {
-  atom
-} from "../../chunks/chunk-WJ67RR7S.js";
-import "../../chunks/chunk-NZLE2WMY.js";
-
-// src/dashboard/atoms/PreferencesAtoms.ts
-var preferencesAtom = atomWithStorage("@alinea/preferences", {
-  scheme: void 0,
-  workspace: void 0,
-  size: 16,
-  language: void 0
-});
-var schemePreferenceAtom = atom(
-  (get) => get(preferencesAtom).scheme,
-  (get, set, scheme) => {
-    set(preferencesAtom, { ...get(preferencesAtom), scheme });
-  }
-);
-var toggleSchemePreferenceAtom = atom(null, (get, set) => {
-  const scheme = get(schemePreferenceAtom);
-  const isLight = scheme === void 0 ? window.matchMedia("(prefers-color-scheme: light)").matches : scheme === "light";
-  const next = isLight ? "dark" : "light";
-  set(schemePreferenceAtom, next);
-});
-var workspacePreferenceAtom = atom(
-  (get) => get(preferencesAtom).workspace,
-  (get, set, workspace) => {
-    set(preferencesAtom, { ...get(preferencesAtom), workspace });
-  }
-);
-var sizePreferenceAtom = atom(
-  (get) => get(preferencesAtom).size,
-  (get, set, size) => {
-    set(preferencesAtom, { ...get(preferencesAtom), size });
-  }
-);
-var languagePreferenceAtom = atom(
-  (get) => get(preferencesAtom).language,
-  (get, set, language) => {
-    set(preferencesAtom, { ...get(preferencesAtom), language });
-  }
-);
-export {
-  languagePreferenceAtom,
-  preferencesAtom,
-  schemePreferenceAtom,
-  sizePreferenceAtom,
-  toggleSchemePreferenceAtom,
-  workspacePreferenceAtom
-};