alinea 1.7.0 → 2.0.0-preview.0

package/dist/field/localiser/LocalisedField.view.d.ts

@@ -0,0 +1,5 @@
+import { type LocalisedField } from 'alinea/field/localiser';
+export interface LocalisedFieldViewProps {
+    field: LocalisedField<string, unknown, unknown, unknown>;
+}
+export declare function LocalisedFieldView({ field }: LocalisedFieldViewProps): import("react").JSX.Element;

package/dist/field/localiser/LocalisedField.view.js

@@ -0,0 +1,63 @@
+import {
+  atomFamily
+} from "../../chunks/chunk-STAJCW4Z.js";
+import {
+  useAtom
+} from "../../chunks/chunk-U4VOHNR2.js";
+import {
+  atom
+} from "../../chunks/chunk-Y7XOMJOC.js";
+import {
+  dist_default
+} from "../../chunks/chunk-I4OYYAX5.js";
+import "../../chunks/chunk-CQ52GEHY.js";
+
+// src/field/localiser/LocalisedField.view.tsx
+import { Tab, TabList, TabPanel, Tabs } from "alinea/components";
+import { createType } from "alinea/core/Type";
+import { NodeEditor } from "alinea/dashboard/app/EntryFields";
+import { useFieldNode } from "alinea/dashboard/hooks";
+import { useMemo } from "react";
+
+// src/field/localiser/LocalisedField.module.css
+var LocalisedField_default = {
+  "LocalisedFieldView": "alinea-LocalisedFieldView"
+};
+
+// src/field/localiser/LocalisedField.view.tsx
+import { jsx, jsxs } from "react/jsx-runtime";
+var styles = dist_default(LocalisedField_default);
+var localeSelection = atomFamily((locales) => {
+  return atom(locales[0]);
+});
+function LocalisedFieldView({ field }) {
+  const { locales, inner } = field.localisation;
+  const [selectedLocale, setSelectedLocale] = useAtom(localeSelection(locales));
+  const node = useFieldNode(field);
+  const types = useMemo(() => {
+    return locales.map(
+      (locale) => createType(locale, {
+        fields: { [locale]: inner }
+      })
+    );
+  }, [locales, inner]);
+  return /* @__PURE__ */ jsxs(
+    Tabs,
+    {
+      selectedKey: selectedLocale,
+      onSelectionChange: (key) => setSelectedLocale(String(key)),
+      className: styles.LocalisedFieldView(),
+      children: [
+        /* @__PURE__ */ jsx(TabList, { children: locales.map((locale) => {
+          return /* @__PURE__ */ jsx(Tab, { id: locale, children: locale.toUpperCase() }, locale);
+        }) }),
+        locales.map((locale, index) => {
+          return /* @__PURE__ */ jsx(TabPanel, { id: locale, children: /* @__PURE__ */ jsx(NodeEditor, { node, type: types[index] }) }, locale);
+        })
+      ]
+    }
+  );
+}
+export {
+  LocalisedFieldView
+};

package/dist/field/localiser/LocalisedFieldTabs.d.ts

@@ -0,0 +1,8 @@
+import type { ReactNode } from 'react';
+export interface LocalisedFieldTabsProps {
+    locales: ReadonlyArray<string>;
+    selectedLocale: string;
+    onSelectedLocaleChange(locale: string): void;
+    children(locale: string): ReactNode;
+}
+export declare function LocalisedFieldTabs({ locales, selectedLocale, onSelectedLocaleChange, children }: LocalisedFieldTabsProps): import("react").JSX.Element;

package/dist/field/localiser/LocalisedFieldTabs.js

@@ -0,0 +1,38 @@
+import {
+  styler
+} from "../../chunks/chunk-I4OYYAX5.js";
+import "../../chunks/chunk-CQ52GEHY.js";
+
+// src/field/localiser/LocalisedFieldTabs.tsx
+import { Tab, TabList, TabPanel, Tabs } from "alinea/components";
+
+// src/field/localiser/LocalisedFieldTabs.module.css
+var LocalisedFieldTabs_default = {
+  "LocalisedFieldTabs": "alinea-LocalisedFieldTabs"
+};
+
+// src/field/localiser/LocalisedFieldTabs.tsx
+import { jsx, jsxs } from "react/jsx-runtime";
+var styles = styler(LocalisedFieldTabs_default);
+function LocalisedFieldTabs({
+  locales,
+  selectedLocale,
+  onSelectedLocaleChange,
+  children
+}) {
+  return /* @__PURE__ */ jsxs(
+    Tabs,
+    {
+      selectedKey: selectedLocale,
+      onSelectionChange: (key) => onSelectedLocaleChange(String(key)),
+      className: styles.LocalisedFieldTabs(),
+      children: [
+        /* @__PURE__ */ jsx(TabList, { children: locales.map((locale) => /* @__PURE__ */ jsx(Tab, { id: locale, children: locale.toUpperCase() }, locale)) }),
+        locales.map((locale) => /* @__PURE__ */ jsx(TabPanel, { id: locale, children: children(locale) }, locale))
+      ]
+    }
+  );
+}
+export {
+  LocalisedFieldTabs
+};

package/dist/field/localiser/Localiser.d.ts

@@ -0,0 +1,25 @@
+import type { FieldOptions } from 'alinea/core/Field';
+import { Field } from 'alinea/core/Field';
+export type LocalisedValue<Locale extends string, Value> = Record<Locale, Value>;
+export interface Localisation<Locale extends string = string, Value = unknown> {
+    locales: ReadonlyArray<Locale>;
+    fallback?: (requested: Locale) => ReadonlyArray<Locale>;
+    inner: Field<Value, unknown, unknown, FieldOptions<Value>>;
+}
+export declare class LocalisedField<Locale extends string, StoredValue, QueryValue, Options> extends Field<LocalisedValue<Locale, StoredValue>, QueryValue, (value: LocalisedValue<Locale, StoredValue>) => void, Omit<Options, 'initialValue' | 'validate'> & FieldOptions<LocalisedValue<Locale, StoredValue>>> {
+    localisation: Localisation<Locale, StoredValue>;
+    constructor(data: ConstructorParameters<typeof Field<LocalisedValue<Locale, StoredValue>, QueryValue, (value: LocalisedValue<Locale, StoredValue>) => void, Omit<Options, 'initialValue' | 'validate'> & FieldOptions<LocalisedValue<Locale, StoredValue>>>>[0], localisation: Localisation<Locale, StoredValue>);
+}
+export interface LocaliserOptions<Locale extends string = string> {
+    locales: ReadonlyArray<Locale>;
+    fallback?: (requested: Locale) => ReadonlyArray<Locale>;
+}
+export interface SelectLocalisedValueOptions<Locale extends string, Value> {
+    value: LocalisedValue<Locale, Value>;
+    locale: string | null;
+    locales: ReadonlyArray<Locale>;
+    fallback?: (requested: Locale) => ReadonlyArray<Locale>;
+    defaultValue?: Value;
+}
+export declare function localiser<const Locale extends string>({ locales, fallback }: LocaliserOptions<Locale>): <StoredValue, QueryValue, Mutator, Options>(field: Field<StoredValue, QueryValue, Mutator, Options>) => LocalisedField<Locale, StoredValue, QueryValue, Options>;
+export declare function selectLocalisedValue<Locale extends string, Value>({ value, locale, locales, fallback, defaultValue }: SelectLocalisedValueOptions<Locale, Value>): Value;

package/dist/field/localiser/Localiser.js

@@ -0,0 +1,140 @@
+import "../../chunks/chunk-CQ52GEHY.js";
+
+// src/field/localiser/Localiser.ts
+import { Field } from "alinea/core/Field";
+import { getField } from "alinea/core/Internal";
+import { viewKeys } from "alinea/dashboard/ViewKeys";
+var LocalisedField = class extends Field {
+  constructor(data, localisation) {
+    super(data);
+    this.localisation = localisation;
+  }
+  localisation;
+};
+function localiser({
+  locales,
+  fallback
+}) {
+  if (locales.length === 0)
+    throw new Error("Field localiser requires at least one locale");
+  return function localise(field) {
+    const data = getField(field);
+    const initialValue = () => {
+      return Object.fromEntries(
+        locales.map((locale) => [locale, Field.initialValue(field)])
+      );
+    };
+    return new LocalisedField(
+      {
+        referencedViews: typeof data.view === "string" ? [data.view, ...data.referencedViews ?? []] : data.referencedViews,
+        view: viewKeys.LocalisedInput,
+        options: {
+          ...data.options,
+          initialValue: initialValue()
+        },
+        defaultValue: initialValue,
+        withInitialValue(value) {
+          const record = value ?? initialValue();
+          let next = record;
+          for (const locale of locales) {
+            const before = record[locale];
+            const after = Field.withInitialValue(field, before);
+            if (after === before) continue;
+            if (next === record) next = { ...record };
+            next[locale] = after;
+          }
+          return next;
+        },
+        async applyLinks(value, loader) {
+          const record = value ?? initialValue();
+          await Promise.all(
+            locales.map(
+              (locale) => Field.applyLinks(field, record[locale], loader)
+            )
+          );
+        },
+        searchableText(value) {
+          const record = value ?? initialValue();
+          return locales.map((locale) => Field.searchableText(field, record[locale])).join("");
+        },
+        references(value, context) {
+          const record = value ?? initialValue();
+          return locales.flatMap(
+            (locale) => Field.references(field, record[locale], {
+              ...context,
+              path: [...context.path, locale]
+            })
+          );
+        },
+        anchors(value, context) {
+          const record = value ?? initialValue();
+          return locales.flatMap(
+            (locale) => Field.anchors(field, record[locale], {
+              ...context,
+              path: [...context.path, locale]
+            })
+          );
+        },
+        normalizeAnchors(value, context) {
+          const record = value ?? initialValue();
+          let next = record;
+          for (const locale of locales) {
+            const before = record[locale];
+            const after = Field.normalizeAnchors(field, before, context);
+            if (after === before) continue;
+            if (next === record) next = { ...record };
+            next[locale] = after;
+          }
+          return next;
+        },
+        async queryValue(value, loader) {
+          const selected = selectLocalisedValue({
+            value: value ?? initialValue(),
+            locale: loader.locale,
+            locales,
+            fallback,
+            defaultValue: Field.initialValue(field)
+          });
+          return Field.queryValue(field, selected, loader);
+        }
+      },
+      {
+        locales,
+        fallback,
+        inner: field
+      }
+    );
+  };
+}
+function selectLocalisedValue({
+  value,
+  locale,
+  locales,
+  fallback,
+  defaultValue
+}) {
+  const localisedValue = value;
+  const requested = selectLocale(locale, locales);
+  const directValue = localisedValue[requested];
+  if (isAvailable(directValue)) return directValue;
+  const fallbacks = fallback?.(requested) ?? [];
+  for (const fallbackLocale of fallbacks) {
+    const fallbackValue = localisedValue[fallbackLocale];
+    if (isAvailable(fallbackValue)) return fallbackValue;
+  }
+  return directValue === void 0 && defaultValue !== void 0 ? defaultValue : directValue;
+}
+function selectLocale(locale, locales) {
+  const matchingLocale = locales.find(
+    (candidate) => candidate.toLowerCase() === locale?.toLowerCase()
+  );
+  return matchingLocale ?? locales[0];
+}
+function isAvailable(value) {
+  return value !== void 0 && value !== null && value !== "";
+}
+export {
+  LocalisedField,
+  localiser,
+  selectLocalisedValue
+};

package/dist/field/localiser.d.ts

@@ -0,0 +1 @@
+export * from 'alinea/field/localiser/Localiser';

package/dist/field/localiser.js

@@ -0,0 +1,2 @@
+// src/field/localiser.ts
+export * from "alinea/field/localiser/Localiser";

package/dist/field/metadata/MetadataAliases.d.ts

@@ -0,0 +1,20 @@
+import type { ListField } from 'alinea/core/field/ListField';
+import type { ListRow } from 'alinea/core/ListRow';
+import { type Type } from 'alinea/core/Type';
+import { type TextField } from 'alinea/field/text';
+export interface MetadataAlias extends ListRow {
+    _type: 'alias';
+    url: string;
+}
+export interface MetadataAliasFields {
+    url: TextField;
+}
+type MetadataAliasType = Type<MetadataAliasFields>;
+export type AliasesField = ListField<MetadataAlias, MetadataAlias, {
+    label: string;
+    schema: {
+        alias: MetadataAliasType;
+    };
+}>;
+export declare function aliases(label?: string): AliasesField;
+export {};

package/dist/field/metadata/MetadataAliases.js

@@ -0,0 +1,22 @@
+import "../../chunks/chunk-CQ52GEHY.js";
+
+// src/field/metadata/MetadataAliases.ts
+import { type } from "alinea/core/Type";
+import { list } from "alinea/field/list";
+import { text } from "alinea/field/text";
+function aliases(label = "URL aliases") {
+  return list(label, {
+    schema: {
+      alias: type("URL alias", {
+        fields: {
+          url: text("URL", {
+            help: "A previous URL that should redirect to this entry"
+          })
+        }
+      })
+    }
+  });
+}
+export {
+  aliases
+};

package/dist/field/metadata/MetadataField.d.ts

@@ -1,34 +1,57 @@
-import type { FieldOptions, WithoutLabel } from 'alinea/core';
+import type { FieldOptions } from 'alinea/core/Field';
 import { RecordField } from 'alinea/core/field/RecordField';
-import { type Type } from 'alinea/core/Type';
+import { ScalarField } from 'alinea/core/field/ScalarField';
+import { Type } from 'alinea/core/Type';
 import { type ImageField, type ImageLink } from 'alinea/field/link';
 import { type ObjectField } from 'alinea/field/object';
 import { type TextField } from 'alinea/field/text';
-export interface MetadataOptions extends FieldOptions<Metadata> {
-    inferTitleFrom?: string;
-    inferDescriptionFrom?: string;
-    inferImageFrom?: string;
+import { type AliasesField, type MetadataAlias } from './MetadataAliases.js';
+export { aliases, type AliasesField, type MetadataAlias } from './MetadataAliases.js';
+export interface MetadataTimestampOptions extends FieldOptions<number | null> {
+    width?: number;
+}
+export interface MetadataUserOptions extends FieldOptions<MetadataAuditUser> {
+    width?: number;
 }
 export interface MetadataFields {
     title: TextField;
     description: TextField;
+    aliases: AliasesField;
     openGraph: ObjectField<{
         image: ImageField;
         title: TextField;
         description: TextField;
     }>;
+    createdAt: MetadataTimestampField;
+    createdBy: MetadataUserField;
+    updatedAt: MetadataTimestampField;
+    updatedBy: MetadataUserField;
+}
+export interface MetadataAuditUser {
+    name: string;
+    email: string;
 }
 export interface Metadata {
     title: string;
     description: string;
+    aliases: Array<MetadataAlias>;
     openGraph: {
         image: ImageLink;
         title: string;
         description: string;
     };
+    createdAt: number | null;
+    createdBy: MetadataAuditUser;
+    updatedAt: number | null;
+    updatedBy: MetadataAuditUser;
 }
-export declare class MetadataField extends RecordField<Metadata, MetadataOptions & {
+export declare class MetadataField extends RecordField<Metadata, {
+    label: string;
     fields: Type<MetadataFields>;
 }> {
 }
-export declare function metadata(label?: string, options?: WithoutLabel<MetadataOptions>): MetadataField;
+export declare class MetadataTimestampField extends ScalarField<number | null, MetadataTimestampOptions> {
+}
+export declare class MetadataUserField extends ScalarField<MetadataAuditUser, MetadataUserOptions> {
+}
+export declare function metadata(label?: string): MetadataField;

package/dist/field/metadata/MetadataField.js

@@ -1,36 +1,152 @@
-import "../../chunks/chunk-NZLE2WMY.js";
+import "../../chunks/chunk-CQ52GEHY.js";
 
 // src/field/metadata/MetadataField.ts
 import { RecordField } from "alinea/core/field/RecordField";
-import { type } from "alinea/core/Type";
-import { viewKeys } from "alinea/dashboard/editor/ViewKeys";
+import { ScalarField } from "alinea/core/field/ScalarField";
+import { Type, type } from "alinea/core/Type";
+import { isRecord } from "alinea/core/util/Objects";
+import { viewKeys } from "alinea/dashboard/ViewKeys";
 import { image } from "alinea/field/link";
 import { object } from "alinea/field/object";
 import { text } from "alinea/field/text";
+import {
+  aliases
+} from "./MetadataAliases.js";
+import {
+  aliases as aliases2
+} from "./MetadataAliases.js";
 var MetadataField = class extends RecordField {
 };
-function metadata(label = "Metadata", options = {}) {
+var MetadataTimestampField = class extends ScalarField {
+};
+var MetadataUserField = class extends ScalarField {
+};
+function metadata(label = "Metadata") {
   const fields = type("Fields", {
     fields: {
-      title: text("Title", { width: 0.5 }),
-      description: text("Description", { multiline: true }),
+      title: text("Title"),
+      description: text("Description", {
+        multiline: true,
+        help: "Optimal length: 120\u2013160 characters",
+        validate(value) {
+          if (value.length > 160) return "Too many characters.";
+        }
+      }),
+      aliases: aliases(),
       openGraph: object("Open Graph", {
         fields: {
           image: image("Image", {
             help: "Recommended size: 1200x630 pixels"
           }),
-          title: text("Title"),
-          description: text("Description", { multiline: true })
+          title: text("Title", { help: "If empty, default title" }),
+          description: text("Description", {
+            multiline: true,
+            help: "If empty, default description"
+          })
         }
-      })
+      }),
+      createdAt: timestamp("Created at"),
+      createdBy: user("Created by"),
+      updatedAt: timestamp("Updated at"),
+      updatedBy: user("Updated by")
     }
   });
   return new MetadataField(fields, {
-    options: { label, ...options, fields },
-    view: viewKeys.MetadataInput
+    options: {
+      label,
+      fields
+    },
+    defaultValue() {
+      return Type.initialValue(fields);
+    },
+    view: viewKeys.MetadataInput,
+    beforeSave(context) {
+      const typeContext = {
+        action: context.action,
+        now: context.now,
+        user: context.user
+      };
+      return Type.beforeSave(
+        fields,
+        metadataWithAudit(context),
+        typeContext
+      );
+    }
+  });
+}
+function timestamp(label) {
+  return new MetadataTimestampField({
+    options: {
+      label,
+      initialValue: null,
+      readOnly: true,
+      width: 0.5
+    },
+    view: viewKeys.MetadataTimestampInput
   });
 }
+function user(label) {
+  return new MetadataUserField({
+    options: {
+      label,
+      initialValue: { name: "", email: "" },
+      readOnly: true,
+      width: 0.5
+    },
+    view: viewKeys.MetadataUserInput
+  });
+}
+function metadataWithAudit({
+  action,
+  now,
+  user: user2,
+  value
+}) {
+  const source = isRecord(value) ? value : {};
+  const timestamp2 = Math.floor(now.getTime() / 1e3);
+  const actor = metadataAuditUser(user2);
+  let next = isRecord(value) ? source : {};
+  function set(key, nextValue) {
+    if (next[key] === nextValue) return;
+    if (next === source) next = { ...source };
+    next[key] = nextValue;
+  }
+  const createdAt = timestampFromValue(source.createdAt);
+  const refreshCreatedFields = action === "create" || action === "translate" || createdAt === void 0;
+  if (refreshCreatedFields) {
+    set("createdAt", timestamp2);
+    set("createdBy", actor);
+  } else {
+    set("createdAt", createdAt);
+  }
+  if (!refreshCreatedFields && !isMetadataAuditUser(source.createdBy)) {
+    set("createdBy", actor);
+  }
+  set("updatedAt", timestamp2);
+  set("updatedBy", actor);
+  return next;
+}
+function metadataAuditUser(user2) {
+  return {
+    name: user2?.name ?? "",
+    email: user2?.email ?? ""
+  };
+}
+function timestampFromValue(value) {
+  if (typeof value === "number" && Number.isFinite(value)) return value;
+  if (typeof value !== "string" || value.length === 0) return void 0;
+  const parsed = new Date(value).getTime();
+  if (Number.isNaN(parsed)) return void 0;
+  return Math.floor(parsed / 1e3);
+}
+function isMetadataAuditUser(value) {
+  if (!isRecord(value)) return false;
+  return typeof value.name === "string" && typeof value.email === "string";
+}
 export {
   MetadataField,
+  MetadataTimestampField,
+  MetadataUserField,
+  aliases2 as aliases,
   metadata
 };

package/dist/field/metadata/MetadataField.view.d.ts

@@ -1,5 +1,13 @@
-import type { MetadataField } from './MetadataField.js';
-export interface MetadataInputProps {
+import { MetadataField, MetadataTimestampField, MetadataUserField } from 'alinea/field/metadata';
+export interface MetadataFieldViewProps {
     field: MetadataField;
 }
-export declare function MetadataInput({ field }: MetadataInputProps): import("react/jsx-runtime").JSX.Element;
+export interface MetadataTimestampFieldViewProps {
+    field: MetadataTimestampField;
+}
+export declare function MetadataTimestampFieldView({ field }: MetadataTimestampFieldViewProps): import("react").JSX.Element;
+export interface MetadataUserFieldViewProps {
+    field: MetadataUserField;
+}
+export declare function MetadataUserFieldView({ field }: MetadataUserFieldViewProps): import("react").JSX.Element;
+export declare function MetadataFieldView({ field }: MetadataFieldViewProps): import("react").JSX.Element;