alinea 2.0.0-preview.13 → 2.0.0-preview.14

package/dist/core/Filter.d.ts

@@ -17,12 +17,24 @@ interface ObjectOps<Fields> {
 interface ArrayOps<Fields> {
     includes?: Filter<Fields>;
 }
+declare const related: unique symbol;
+/**
+ * A field matched by a query of related entries, eg. `_referenced`. Its
+ * condition holds when the query finds an entry.
+ */
+export interface Related<Query> {
+    [related]: Query;
+}
+/** A query of related entries used as a condition */
+export interface RelationCondition {
+    edge: string;
+}
 type FieldOps<Fields> = {
     [K in keyof Fields]?: Condition<Fields[K]>;
 };
-export type Condition<Value> = [Value] extends [Primitive] ? Ops<Value> | Value : [Value] extends [Array<any>] ? ArrayOps<Value[0]> : ObjectOps<Value>;
+export type Condition<Value> = [Value] extends [Related<infer Query>] ? Condition<boolean> | Query : [Value] extends [Primitive] ? Ops<Value> | Value : [Value] extends [Array<any>] ? ArrayOps<Value[0]> : ObjectOps<Value>;
 /** A condition on a field whose type is not known */
-export type AnyCondition = Primitive | Ops<unknown> | ArrayOps<unknown> | ObjectOps<unknown>;
+export type AnyCondition = Primitive | Ops<unknown> | ArrayOps<unknown> | ObjectOps<unknown> | RelationCondition;
 /**
  * A filter on known fields that also accepts conditions on any other field,
  * for example the fields of the entry types an entry picker can select
@@ -75,6 +87,11 @@ export type ConditionNode = {
 } | {
     op: 'includes';
     item: ConditionNode;
+}
+/** Holds when the query of related entries finds an entry */
+ | {
+    op: 'relation';
+    query: RelationCondition;
 };
 export declare function parseFilter(filter: unknown): FilterNode;
 export declare function parseCondition(condition: unknown): ConditionNode;

package/dist/core/Filter.js

@@ -21,6 +21,8 @@ function parseFilter(filter) {
 function parseCondition(condition) {
   if (condition === void 0) return { op: "and", nodes: [] };
   if (!isRecord(condition)) return { op: "is", value: condition };
+  if (typeof condition.edge === "string")
+    return { op: "relation", query: { ...condition, edge: condition.edge } };
   const nodes = Array();
   for (const [op, value] of Object.entries(condition)) {
     if (value === void 0) continue;
@@ -121,8 +123,11 @@ function conditionCheck(node) {
       const check = conditionCheck(node.item);
       return (value) => Array.isArray(value) && value.some(check);
     }
+    case "relation":
+      throw new Error(relationMessage);
   }
 }
+var relationMessage = "Relation filters such as `_referenced: Query.referencedBy(...)` only work in queries (graph.find, EntryTable, overview filters), they cannot be checked against loaded entries";
 function defaultField(input, name) {
   return isRecord(input) ? input[name] : void 0;
 }

package/dist/core/Graph.d.ts

@@ -46,7 +46,15 @@ export interface EdgeEntry {
     edge: 'entrySingle';
     field: HasField & Expr;
 }
-export type Edge = EdgeTranslations | EdgeChildren | EdgeParents | EdgeSiblings | EdgeParent | EdgeNext | EdgePrevious | EdgeEntries | EdgeEntry;
+/**
+ * Entries that link to the entry, through any field or through the given
+ * link field of their type
+ */
+export interface EdgeReferencedBy {
+    edge: 'referencedBy';
+    field?: HasField & Expr;
+}
+export type Edge = EdgeTranslations | EdgeChildren | EdgeParents | EdgeSiblings | EdgeParent | EdgeNext | EdgePrevious | EdgeEntries | EdgeEntry | EdgeReferencedBy;
 /** Options that change a query result into a single entry or a count */
 export interface QueryModifiers {
     first?: true;
@@ -195,5 +203,5 @@ export declare abstract class Graph {
     get<Selection extends SelectionGuard = undefined, const Type extends TypeGuard = undefined, Include extends IncludeGuard = undefined>(query: GraphQuery<Selection, Type, Include>): Promise<QueryResult<Selection, Type, Include>>;
     count<Selection extends SelectionGuard = undefined, const Type extends TypeGuard = undefined, Include extends IncludeGuard = undefined>(query: GraphQuery<Selection, Type, Include>): Promise<number>;
 }
-export declare function querySource(query: unknown): "children" | "entryMultiple" | "entrySingle" | "next" | "parent" | "parents" | "previous" | "siblings" | "translations" | undefined;
+export declare function querySource(query: unknown): "children" | "entryMultiple" | "entrySingle" | "next" | "parent" | "parents" | "previous" | "referencedBy" | "siblings" | "translations" | undefined;
 export {};

package/dist/core/Overview.d.ts

@@ -2,7 +2,7 @@ import type { EntryStatus } from './Entry.js';
 import type { EntryFilterFields } from './EntryFields.js';
 import { Expr } from './Expr.js';
 import type { OpenFilter } from './Filter.js';
-import type { EdgeQuery, GraphQuery, InferProjection, Order, Projection } from './Graph.js';
+import type { EdgeQuery, Graph, GraphQuery, InferProjection, Order, Projection } from './Graph.js';
 import type { Type } from './Type.js';
 import type { View } from './View.js';
 /** Horizontal alignment of a column's header and cells */
@@ -12,9 +12,10 @@ export type OverviewColumnPosition = 'start' | 'end';
 /** A fixed width in pixels or a fraction of the remaining space */
 export type OverviewColumnWidth = number | `${number}fr`;
 /**
- * A value to sort entries by: an expression such as a field, or a query of a
+ * A value to sort entries by: an expression such as a field, a query of a
  * linked entry that selects a single expression, eg.
- * `Product.brand.first({select: Entry.title})`
+ * `Product.brand.first({select: Entry.title})`, or a count of related
+ * entries, eg. `Query.referencedBy({type: Product, count: true})`
  */
 export type OverviewSortValue = Expr<any> | EdgeQuery<Expr<any>>;
 /** One projection per entry type, keyed by the type names of the schema */
@@ -99,12 +100,39 @@ export interface OverviewFilterOption {
     /** The condition entries match when the option is picked */
     filter: OpenFilter<EntryFilterFields>;
 }
+/** The choices of an overview filter, keyed by a name unique within it */
+export interface OverviewFilterOptions {
+    [key: string]: OverviewFilterOption;
+}
+/** What the options of an overview filter can be loaded with */
+export interface OverviewFilterContext {
+    /** Query the content, eg. to list an option per entry of a type */
+    graph: Graph;
+    /** The locale the overview lists, null for unlocalised roots */
+    locale: string | null;
+}
 /** A filter editors can apply in the "Filter and sort" menu of an overview */
 export interface OverviewFilter {
     /** The heading of the options in the menu, eg. `File type` */
     label: string;
-    /** The choices, keyed by a name that is unique within the filter */
-    options: Record<string, OverviewFilterOption>;
+    /**
+     * The choices, keyed by a name that is unique within the filter, or a
+     * function that loads them, eg. an option per category:
+     *
+     * ```ts
+     * async options({graph}) {
+     *   const categories = await graph.find({
+     *     type: Category,
+     *     select: {id: Entry.id, title: Entry.title}
+     *   })
+     *   return Object.fromEntries(categories.map(category => [category.id, {
+     *     label: category.title,
+     *     filter: {category: {has: {_entry: category.id}}}
+     *   }]))
+     * }
+     * ```
+     */
+    options: OverviewFilterOptions | ((context: OverviewFilterContext) => OverviewFilterOptions | Promise<OverviewFilterOptions>);
     /**
      * Editors can pick several options, entries then match any of them.
      * Defaults to false: picking an option replaces the picked one.
@@ -128,6 +156,36 @@ export interface OverviewActionProps {
      */
     query: GraphQuery<undefined, Type | Array<Type> | undefined, undefined>;
 }
+/** A tab above the listed entries, each lists the entries of its filter */
+export interface OverviewTab {
+    /** Shown on the tab, eg. `Active` */
+    label: string;
+    /**
+     * The condition entries match when the tab is selected, like the options of
+     * a filter. A tab without a filter lists every child.
+     */
+    filter?: OpenFilter<EntryFilterFields>;
+}
+/** Props of an `overview.header` view */
+export interface OverviewHeaderProps {
+    workspace: string;
+    root: string;
+    /** The entry whose children are listed, null for the root */
+    parentId: string | null;
+    locale: string | null;
+    /** The search terms entered in the overview */
+    search: string;
+    /**
+     * The condition of the selected tab and the applied filters, undefined
+     * when none applies
+     */
+    filter: OpenFilter<EntryFilterFields> | undefined;
+    /**
+     * A query for the listed entries, without paging. Pass it to
+     * `useGraph().find({...query, select})`, eg. to total them.
+     */
+    query: GraphQuery<undefined, Type | Array<Type> | undefined, undefined>;
+}
 interface OverviewColumnBase<Value> {
     /** The column header */
     header: string;
@@ -212,6 +270,12 @@ export interface OverviewOptions {
      * applied filter, and the search terms.
      */
     filters?: Record<string, OverviewFilter>;
+    /**
+     * Tabs above the listed children, keyed by a name kept in the url. The
+     * first tab is selected by default. Entries match the filter of the
+     * selected tab, the applied filters and the search terms.
+     */
+    tabs?: Record<string, OverviewTab>;
     /** The default layout, editors can still switch */
     layout?: 'table' | 'cards';
     /**
@@ -221,6 +285,11 @@ export interface OverviewOptions {
     thumbnail?: Expr<any> | Record<string, Expr<any>>;
     /** Components rendered in the overview toolbar, eg. an export button */
     actions?: Array<View<OverviewActionProps>>;
+    /**
+     * A component rendered above the listed children, eg. totals or a chart of
+     * the listed entries
+     */
+    header?: View<OverviewHeaderProps>;
 }
 /** Create a column for an overview */
 export declare function column<const Select extends OverviewColumnSelect | undefined = undefined>(options: OverviewColumnOptions<Select, OverviewColumnValue<Select>>): OverviewColumn<OverviewColumnValue<Select>>;

package/dist/core/Overview.js

@@ -13,6 +13,7 @@ var Overview;
     if (!overview) return [];
     const views = [
       ...overview.actions ?? [],
+      overview.header,
       ...values(overview.columns ?? {}).map((column2) => column2.view)
     ];
     return views.filter((view) => typeof view === "string");

package/dist/core/Root.js

@@ -3,7 +3,7 @@ import {
   boolean,
   object,
   string
-} from "../chunks/chunk-UPY2RUZF.js";
+} from "../chunks/chunk-TWBREZWC.js";
 import "../chunks/chunk-CQ52GEHY.js";
 
 // src/core/Root.ts

package/dist/core/Scope.d.ts

@@ -25,6 +25,11 @@ export declare class Scope {
     fieldOf(field: Field): [type: string, path: string] | undefined;
     locationOf(entity: Entity): string[] | undefined;
     nameOf(entity: Entity): string | undefined;
+    /**
+     * Where a field stores its value in the entry data, eg. `['seo', 'title']`
+     * for a field of an object field
+     */
+    dataPathOf(field: Field): Array<string> | undefined;
     /** Configured spellings of a locale, matched case-insensitively. */
     locales(locale: string): Array<string>;
     stringify(input: any): string;

package/dist/core/Scope.js

@@ -41,6 +41,7 @@ var Scope = class {
   #paths = /* @__PURE__ */ new Map();
   #locales = /* @__PURE__ */ new Map();
   #nested = /* @__PURE__ */ new Map();
+  #nestedKeys = /* @__PURE__ */ new Map();
   #shared = /* @__PURE__ */ new Set();
   constructor(config) {
     for (const [workspaceName, workspace] of entries(config.workspaces)) {
@@ -67,10 +68,12 @@ var Scope = class {
     for (const [typeName, type] of entries(config.schema))
       for (const [fieldName, field] of entries(type))
         this.#insertNested(field, ["Field", typeName, fieldName]);
+    for (const [field, path] of this.#nested)
+      this.#nestedKeys.set(path.join("."), field);
   }
   // Fields of object fields get a key, eg. Field.Type.object.field, so roles
-  // can target them. They are kept apart from the other entities: queries
-  // select top level fields only. A field instance used in more than one
+  // can target them and queries can select them. They are kept apart from the
+  // other entities, which have a name. A field instance used in more than one
   // place has no single key, so it can't be targeted.
   #insertNested(field, path) {
     if (!hasType(field)) return;
@@ -111,14 +114,27 @@ var Scope = class {
   nameOf(entity) {
     return this.#paths.get(entity)?.at(-1);
   }
+  /**
+   * Where a field stores its value in the entry data, eg. `['seo', 'title']`
+   * for a field of an object field
+   */
+  dataPathOf(field) {
+    if (this.#shared.has(field))
+      throw new Error(
+        "Field is used in more than one place, select the field containing it"
+      );
+    const path = this.#paths.get(field) ?? this.#nested.get(field);
+    if (path?.[0] !== "Field") return;
+    return path.slice(2);
+  }
   /** Configured spellings of a locale, matched case-insensitively. */
   locales(locale) {
     return this.#locales.get(locale.toLowerCase()) ?? [locale];
   }
   stringify(input) {
     const result = JSON.stringify(input, (key, value) => {
-      if (this.#paths.has(value))
-        return { [ENTITY_KEY]: this.#paths.get(value)?.join(".") };
+      const path = this.#paths.get(value) ?? this.#nested.get(value);
+      if (path) return { [ENTITY_KEY]: path.join(".") };
       if (value && typeof value === "object" && hasExpr(value))
         return { [EXPR_KEY]: getExpr(value) };
       return value;
@@ -131,7 +147,8 @@ var Scope = class {
         const props = Object.keys(value);
         if (props.length === 1) {
           const [key2] = props;
-          if (key2 === ENTITY_KEY) return this.#keys.get(value[key2]);
+          if (key2 === ENTITY_KEY)
+            return this.#keys.get(value[key2]) ?? this.#nestedKeys.get(value[key2]);
           if (key2 === EXPR_KEY) return new Expr(value[key2]);
         }
       }

package/dist/core/Type.d.ts

@@ -1,3 +1,4 @@
+import type { EntryActionProps } from './DashboardEntry.js';
 import type { ComponentType } from 'react';
 import type { Config } from './Config.js';
 import type { EntryStatus } from './Entry.js';
@@ -47,6 +48,8 @@ export declare namespace Type {
     function references(type: Type, value: Record<string, unknown>, path?: Array<string>, labels?: Array<string>): Array<EntryReferenceTarget>;
     function fields(type: Type): Record<string, Field>;
     function sections(type: Type): Section[];
+    /** Fields edited in the settings of a block, or a Settings tab of an entry */
+    function settings(type: Type): FieldsDefinition | undefined;
     function isContainer(type: Type): boolean;
     function field(type: Type, name: string): Field | undefined;
     function isType(type: any): type is Type;
@@ -65,12 +68,24 @@ export declare namespace Type {
 export interface FieldsDefinition {
     [key: string]: Field;
 }
-export interface TypeConfig<Definition> {
+export interface TypeConfig<Definition, Settings = {}> {
     fields: Definition;
+    /**
+     * Fields shown in the settings sheet of a block, below its label and
+     * anchor. Entries of the type show them in a Settings tab. They are stored
+     * and queried like the other fields.
+     */
+    settings?: Settings;
     /** Accepts entries of these types as children */
     contains?: Array<string | Type>;
     /** How the dashboard lists the children of entries of this type */
     overview?: OverviewOptions;
+    /**
+     * Components rendered in the header of the entry editor, next to the
+     * publish button, eg. a button that exports or sends the entry. They can
+     * read the fields of the entry with the hooks of `alinea/cms`.
+     */
+    actions?: Array<View<EntryActionProps>>;
     /**
      * Order children entries in the sidebar content tree
      * @deprecated Use `overview.sort`
@@ -88,7 +103,11 @@ export interface TypeConfig<Definition> {
     collapsed?: boolean;
     /** An icon (React component) to represent this type in the dashboard */
     icon?: ComponentType;
-    /** A React component used to view an entry of this type in the dashboard */
+    /**
+     * A React component, or a path to one, that replaces the form of entries of
+     * this type below the entry header. It edits the fields of the entry with
+     * the hooks of `alinea/cms`.
+     */
     view?: View<{
         type: Type;
     }>;
@@ -112,17 +131,17 @@ export interface TypeConfig<Definition> {
     preview?: Preview;
 }
 /** Types that only hold children can leave out their fields */
-export interface ContainerTypeConfig<Definition> extends Omit<TypeConfig<Definition>, 'fields' | 'contains'> {
+export interface ContainerTypeConfig<Definition, Settings = {}> extends Omit<TypeConfig<Definition, Settings>, 'fields' | 'contains'> {
     fields?: Definition;
     /** Accepts entries of these types as children */
     contains: Array<string | Type>;
 }
-export interface TypeInternal extends TypeConfig<FieldsDefinition> {
+export interface TypeInternal extends TypeConfig<FieldsDefinition, FieldsDefinition> {
     label: string;
     allFields: Record<string, Field>;
     sections: Array<Section>;
 }
 /** Create a new type */
-export declare function type<Fields extends FieldsDefinition = {}>(label: string, config: TypeConfig<Fields> | ContainerTypeConfig<Fields>): Type<Fields>;
-export declare function createType<Fields extends FieldsDefinition = {}>(label: string, { fields: definition, ...config }: TypeConfig<Fields> | ContainerTypeConfig<Fields>): Type<Fields>;
+export declare function type<Fields extends FieldsDefinition = {}, Settings extends FieldsDefinition = {}>(label: string, config: TypeConfig<Fields, Settings> | ContainerTypeConfig<Fields, Settings>): Type<Fields & Settings>;
+export declare function createType<Fields extends FieldsDefinition = {}, Settings extends FieldsDefinition = {}>(label: string, { fields: definition, ...config }: TypeConfig<Fields, Settings> | ContainerTypeConfig<Fields, Settings>): Type<Fields & Settings>;
 export {};

package/dist/core/Type.js

@@ -1,7 +1,9 @@
 import {
+  instance,
   object,
-  string
-} from "../chunks/chunk-UPY2RUZF.js";
+  string,
+  union
+} from "../chunks/chunk-TWBREZWC.js";
 import "../chunks/chunk-CQ52GEHY.js";
 
 // src/core/Type.ts
@@ -89,6 +91,11 @@ var Type;
     return getType(type2).sections;
   }
   Type2.sections = sections;
+  function settings(type2) {
+    const { settings: settings2 } = getType(type2);
+    return settings2 && keys(settings2).length > 0 ? settings2 : void 0;
+  }
+  Type2.settings = settings;
   function isContainer(type2) {
     return Boolean(getType(type2).contains);
   }
@@ -186,7 +193,7 @@ var Type;
   Type2.defaultView = defaultView;
   const TypeOptions = object({
     defaultView: string.optional,
-    view: string.optional,
+    view: union(string, instance(Function)).optional,
     summaryRow: string.optional,
     summaryThumb: string.optional
   });
@@ -203,11 +210,12 @@ var Type;
   }
   Type2.validate = validate;
   function referencedViews(type2) {
-    const { view, summaryRow, summaryThumb, overview: overview2 } = getType(type2);
+    const { view, summaryRow, summaryThumb, overview: overview2, actions } = getType(type2);
     return [
       view,
       summaryRow,
       summaryThumb,
+      ...actions ?? [],
       ...Overview.referencedViews(overview2),
       ...viewsOfDefinition(getType(type2).fields)
     ].filter((v) => typeof v === "string");
@@ -242,9 +250,9 @@ function viewsOfDefinition(definition) {
   });
 }
 function type(label, config) {
-  const instance = createType(label, config);
-  Type.validate(instance);
-  return instance;
+  const instance2 = createType(label, config);
+  Type.validate(instance2);
+  return instance2;
 }
 function createType(label, {
   fields: definition = {},
@@ -273,6 +281,16 @@ function createType(label, {
     }
   }
   addCurrent();
+  const taken = new Set(fields.map(([key]) => key));
+  for (const [key, value] of entries(config.settings ?? {})) {
+    const own = Section.isSection(value) ? entries(Section.fields(value)) : Field.isField(value) ? [[key, value]] : [];
+    for (const [name, field] of own) {
+      if (taken.has(name))
+        throw new Error(`Field "${name}" is defined twice in Type "${label}"`);
+      taken.add(name);
+      fields.push([name, field]);
+    }
+  }
   const allFields = fromEntries(fields);
   return {
     ...allFields,

package/dist/core/db/LocalStore.d.ts

@@ -6,6 +6,13 @@ import type { WriteableGraph } from './WriteableGraph.js';
 export interface SyncOptions {
     /** Skip entry validation for a remote whose entries were already validated. */
     validate?: boolean;
+    /** Called as files arrive from the remote, once there are files to fetch. */
+    onProgress?(progress: SyncProgress): void;
+}
+/** Files fetched from the remote during a sync. */
+export interface SyncProgress {
+    loaded: number;
+    total: number;
 }
 /**
  * A locally available entry store: a writeable graph backed by a source that

package/dist/core/field/CreateField.d.ts

@@ -1,8 +1,7 @@
 import type { Field, FieldOptions, WithoutLabel } from '../Field.js';
 import type { Expand } from '../util/Types.js';
 import type { View } from '../View.js';
-export interface Create<Value, Options = object> extends Field<Value, Value, (value: Value) => void, FieldOptions<Value> & Options> {
-}
+export type Create<Value, Options = object> = Field<Value, Value, (value: Value) => void, FieldOptions<Value> & Options>;
 export type Options<F> = Expand<F extends Field<any, any, any, infer Options> ? WithoutLabel<Options & FieldOptions<any>> : WithoutLabel<FieldOptions<any>>>;
 export interface CreateConfig<Value, Options> {
     label: string;

package/dist/core/source/Source.d.ts

@@ -13,6 +13,8 @@ export interface Source extends RemoteSource {
     /** Consume remote blobs incrementally instead of materializing one bundle. */
     applyChangesFrom?(remote: RemoteSource, batch: ChangesBatch, tree: ReadonlyTree): Promise<void>;
 }
+/** Pin the tree while streaming blobs from the revision already fetched. */
+export declare function sourceAtTree(source: RemoteSource, tree: ReadonlyTree): RemoteSource;
 export declare function applyChangesFrom(source: Source, remote: RemoteSource, batch: ChangesBatch, tree: ReadonlyTree): Promise<void>;
 export declare function bundleContents(source: RemoteSource, batch: ChangesBatch): Promise<ChangesBatch>;
 export declare function diff(source: Source, remote: RemoteSource): Promise<ChangesBatch>;

package/dist/core/source/Source.js

@@ -3,6 +3,16 @@ import "../../chunks/chunk-CQ52GEHY.js";
 // src/core/source/Source.ts
 import { accumulate } from "../util/Async.js";
 import { hashBlob } from "./GitUtils.js";
+function sourceAtTree(source, tree) {
+  return {
+    async getTreeIfDifferent(revision) {
+      return revision === tree.sha ? void 0 : tree;
+    },
+    getBlobs(shas, options) {
+      return source.getBlobs(shas, options);
+    }
+  };
+}
 async function applyChangesFrom(source, remote, batch, tree) {
   if (source.applyChangesFrom)
     return source.applyChangesFrom(remote, batch, tree);
@@ -118,6 +128,7 @@ export {
   applyChangesFrom,
   bundleContents,
   diff,
+  sourceAtTree,
   syncWith,
   transaction
 };

package/dist/core/util/Async.d.ts

@@ -8,6 +8,8 @@ export interface MapConcurrentOptions {
 /** Map concurrently while yielding results as they complete. */
 export declare function mapConcurrent<T, TResult>(iterable: Iterable<T>, mapper: (item: T, signal?: AbortSignal) => Promise<TResult>, options: MapConcurrentOptions): AsyncGenerator<TResult>;
 export declare function genEffect<T, TReturn>(gen: AsyncIterable<T, TReturn>, effect: (result: T) => void): AsyncIterable<T>;
+/** Settle like `promise`, or reject when it takes longer than `ms`. */
+export declare function within<T>(promise: Promise<T>, ms: number): Promise<T>;
 /** Run tasks one after another; a failed task does not block the next one. */
 export declare class TaskQueue {
     #private;

package/dist/core/util/Async.js

@@ -100,6 +100,16 @@ function genEffect(gen, effect) {
     }
   };
 }
+function within(promise, ms) {
+  let timer;
+  const expired = new Promise((_, reject) => {
+    timer = setTimeout(
+      () => reject(new Error(`Timed out after ${ms / 1e3}s`)),
+      ms
+    );
+  });
+  return Promise.race([promise, expired]).finally(() => clearTimeout(timer));
+}
 var TaskQueue = class {
   #tail = Promise.resolve();
   run(task) {
@@ -119,5 +129,6 @@ export {
   accumulate,
   genEffect,
   mapConcurrent,
-  toGenerator
+  toGenerator,
+  within
 };

package/dist/core/util/Checks.js

@@ -1,6 +1,6 @@
 import {
   type
-} from "../../chunks/chunk-UPY2RUZF.js";
+} from "../../chunks/chunk-TWBREZWC.js";
 import "../../chunks/chunk-CQ52GEHY.js";
 
 // src/core/util/Checks.ts

package/dist/core/util/Slugs.js

@@ -3,15 +3,16 @@ import "../../chunks/chunk-CQ52GEHY.js";
 // src/core/util/Slugs.ts
 var strip = /([^\p{L}\p{N}\p{M}\p{Emoji}\p{Emoji_Component}]|\p{P}(?!\u{fe0f}))+/u;
 var stripGlobal = new RegExp(strip.source, "gu");
-var ignore = /['’]/g;
+var ignore = /['’\u00ad]/;
+var ignoreGlobal = new RegExp(ignore.source, "g");
 var stripAccents = /(\p{Script=Latin})\p{M}+/gu;
 var separator = "-";
 var trim = new RegExp(`^${separator}+|${separator}+$`, "g");
 function isSeparator(char) {
-  return strip.test(char);
+  return !ignore.test(char) && strip.test(char);
 }
 function slugify(input) {
-  return input.normalize("NFKD").replace(stripAccents, "$1").replace(ignore, "").replace(stripGlobal, separator).replace(trim, "").toLowerCase();
+  return input.normalize("NFKD").replace(stripAccents, "$1").replace(ignoreGlobal, "").replace(stripGlobal, separator).replace(trim, "").toLowerCase();
 }
 export {
   isSeparator,

package/dist/dashboard/App.css

@@ -1,6 +1,8 @@
 /* src/theme.css */
-:root {
+:root[data-alinea-theme] {
   color-scheme: light dark;
+}
+:where([data-alinea-theme]:not([data-alinea-theme] *)) {
   --alinea-gray-0: #ffffff;
   --alinea-gray-50: #f9fafb;
   --alinea-gray-100: #f3f4f7;
@@ -48,7 +50,7 @@
   --alinea-green-700: #007a55;
   --alinea-green-800: #006045;
 }
-:root {
+:where([data-alinea-theme]:not([data-alinea-theme] *)) {
   --alinea-font: "Inter", sans-serif;
   --alinea-mono-font: "JetBrains Mono", monospace;
   --alinea-font-size-base: 0.8125rem;
@@ -65,8 +67,8 @@
   --alinea-warning-fg: var(--alinea-gray-900);
   --alinea-success: light-dark(var(--alinea-green-600), var(--alinea-green-500));
   --alinea-ring: var(--alinea-blue-500);
+  --alinea-workspace-color: var(--alinea-primary);
 }
-:root,
 [data-alinea-theme] {
   --alinea-transition: 0.2s ease-out;
   --alinea-radius-sm: calc(var(--alinea-radius) / 2);
@@ -107,10 +109,10 @@
   --alinea-shadow-tooltip: 0 8px 20px rgb(0 0 0 / 10%);
   --alinea-shadow-modal: 0 2px 13px rgb(0 0 0 / 11%);
 }
-:root[data-theme=light] {
+[data-alinea-theme][data-theme=light] {
   color-scheme: light;
 }
-:root[data-theme=dark] {
+[data-alinea-theme][data-theme=dark] {
   color-scheme: dark;
 }
 
@@ -273,14 +275,14 @@
 }
 
 /* src/dashboard/global.css */
-html,
-body,
-#root {
+:where(html[data-alinea-theme]),
+:where(html[data-alinea-theme]) body,
+:where(html[data-alinea-theme]) #root {
   height: 100%;
   margin: 0;
   font-family: var(--alinea-font);
 }
-* {
+:where([data-alinea-theme], [data-alinea-theme] *) {
   box-sizing: border-box;
   padding: 0;
   margin: 0;
@@ -292,12 +294,12 @@ body[data-disable-transition=true] {
     transition: none !important;
   }
 }
-a {
+:where([data-alinea-theme] a) {
   color: inherit;
   font: inherit;
   text-decoration: none;
 }
-button {
+:where([data-alinea-theme] button) {
   background: none;
   border: none;
   color: inherit;

package/dist/dashboard/App.d.ts

@@ -17,3 +17,4 @@ export interface AppProps {
 }
 export declare const appAtom: import("jotai").Atom<readonly [false, string | number | bigint | boolean | import("react").JSX.Element | Iterable<ReactNode> | null | undefined] | readonly [true, string | number | bigint | boolean | import("react").JSX.Element | Iterable<ReactNode> | null | undefined]>;
 export declare function App(props: AppProps): import("react").JSX.Element;
+export declare function AppLoading(): import("react").JSX.Element;