rimecms 1.0.0 → 1.0.1

package/dist/adapter-sqlite/generate-schema/templates.server.d.ts

@@ -1,5 +1,5 @@
-import type { FieldReference } from '../../core/fields/builders/form-field-builder.js';
 import type { ColumnDeclaration, TableDeclaration } from '../../core/adapter.js';
+import type { FieldReference } from '../../core/fields/builders/form-field-builder.js';
 import { type TableName } from '../naming.server.js';
 /**
  * Generates the standard imports needed for Drizzle ORM schema definitions
@@ -113,10 +113,11 @@ export declare const templateUniqueRequired: (field: {
 export declare const templatePathsTable: (owner: TableName) => string;
 /** Template rows Relation */
 /**
- * The whole schema's relations, in one declaration.
+ * The drizzle relations of the whole schema. A read lists them in its `with` to load related rows
+ * in the same query, by the names given here.
  *
- * Every relation rime generates is the same shape — a child row points at its owner through
- * `ownerId` — so the tree is `parent -> children` and both directions fall out of it:
+ * A child table (blocks, tree…) points at its owner through `ownerId`. It gets a relation each way,
+ * named after the table on the other end:
  *
  * ```ts
  * export const relations = defineRelations(tables, (r) => ({
@@ -131,14 +132,13 @@ export declare const templatePathsTable: (owner: TableName) => string;
  * }));
  * ```
  *
- * A relation is keyed by the table on the other end, which is what `buildWithParam` names when it
- * builds a `with`.
- *
- * A reference the read resolves is the other shape: the owner's row points at its target through
- * the field's own column, one direction, keyed by `joinName(column)`:
+ * A reference field that stores another document's id in its own column: `updatedBy` holds a staff id.
+ * It gets one relation, from that column to the target, named after the column. Two columns can
+ * point at the same table:
  *
  * ```ts
  * pages: {
+ *   createdBy__$doc: r.one.staff({ from: r.pages.createdBy, to: r.staff.id }),
  *   updatedBy__$doc: r.one.staff({ from: r.pages.updatedBy, to: r.staff.id })
  * }
  * ```

package/dist/adapter-sqlite/generate-schema/templates.server.js

@@ -1,6 +1,6 @@
 import { toSnakeCase } from '../../util/string.js';
-import { baseTableName, declaredTableProperty, getSchemaColumnNames, joinName, tableName } from '../naming.server.js';
 import dedent from 'dedent';
+import { baseTableName, declaredTableProperty, getSchemaColumnNames, joinName, tableName } from '../naming.server.js';
 const s = toSnakeCase;
 /**
  * Generates the standard imports needed for Drizzle ORM schema definitions
@@ -204,10 +204,11 @@ export const ${table} = sqliteTable('${table}', {
 };
 /** Template rows Relation */
 /**
- * The whole schema's relations, in one declaration.
+ * The drizzle relations of the whole schema. A read lists them in its `with` to load related rows
+ * in the same query, by the names given here.
  *
- * Every relation rime generates is the same shape — a child row points at its owner through
- * `ownerId` — so the tree is `parent -> children` and both directions fall out of it:
+ * A child table (blocks, tree…) points at its owner through `ownerId`. It gets a relation each way,
+ * named after the table on the other end:
  *
  * ```ts
  * export const relations = defineRelations(tables, (r) => ({
@@ -222,14 +223,13 @@ export const ${table} = sqliteTable('${table}', {
  * }));
  * ```
  *
- * A relation is keyed by the table on the other end, which is what `buildWithParam` names when it
- * builds a `with`.
- *
- * A reference the read resolves is the other shape: the owner's row points at its target through
- * the field's own column, one direction, keyed by `joinName(column)`:
+ * A reference field that stores another document's id in its own column: `updatedBy` holds a staff id.
+ * It gets one relation, from that column to the target, named after the column. Two columns can
+ * point at the same table:
  *
  * ```ts
  * pages: {
+ *   createdBy__$doc: r.one.staff({ from: r.pages.createdBy, to: r.staff.id }),
  *   updatedBy__$doc: r.one.staff({ from: r.pages.updatedBy, to: r.staff.id })
  * }
  * ```

package/dist/adapter-sqlite/paths.server.js

@@ -56,28 +56,37 @@ const createPathsHandle = ({ db, tables }) => {
                 .returning();
             return row;
         },
-        // One statement for every locale: each row takes its new parent's path in its own locale.
-        moveUnder: async ({ slug, ownerId, parentId }) => {
+        // One statement per locale, in one transaction: each row takes its new parent's path in its
+        // locale, and its slug there.
+        moveUnder: async ({ slug, ownerId, parentId, slugs }) => {
             const { paths } = tablesOf(slug);
-            const moved = await db
-                .update(paths)
-                .set({ parentPath: parentId ? parentPathIn(paths, parentId, paths.locale) : null })
-                .where(eq(paths.ownerId, ownerId))
-                .returning();
-            return rowsOf(moved);
+            return db.transaction(async (tx) => {
+                const moved = [];
+                for (const [locale, value] of Object.entries(slugs)) {
+                    const rows = await tx
+                        .update(paths)
+                        .set({
+                        slug: value,
+                        parentPath: parentId ? parentPathIn(paths, parentId, locale) : null
+                    })
+                        .where(and(eq(paths.ownerId, ownerId), eq(paths.locale, locale)))
+                        .returning();
+                    moved.push(...rows);
+                }
+                return rowsOf(moved);
+            });
         },
-        detachChildren: async ({ slug, ownerId }) => {
+        children: async ({ slug, ownerId }) => {
             const { paths } = tablesOf(slug);
             const self = alias(paths, 'self');
-            const detached = await db
-                .update(paths)
-                .set({ parentPath: null })
+            const rows = await db
+                .selectDistinct({ ownerId: paths.ownerId })
+                .from(paths)
                 .where(sql `(${paths.locale}, ${paths.parentPath}) IN (${db
                 .select({ locale: self.locale, path: self.path })
                 .from(self)
-                .where(eq(self.ownerId, ownerId))})`)
-                .returning();
-            return rowsOf(detached);
+                .where(eq(self.ownerId, ownerId))})`);
+            return rows.map((row) => row.ownerId);
         },
         // `path/` <= p < `path0` is every path starting with `path/`, read off the unique index:
         // '0' is the character after '/'.

package/dist/adapter-sqlite/rows.server.d.ts

@@ -30,7 +30,7 @@ export declare const bundles: ({ db, tables, configCtx, config, versions }: Hand
     };
     self: {
         slug: never;
-        config: BuiltCollection | BuiltArea;
+        config: BuiltArea | BuiltCollection;
         versions: VersionsTable | undefined;
     };
 };

package/dist/core/adapter.d.ts

@@ -330,17 +330,21 @@ export interface PathsHandle {
         locale: string;
         value: string;
     }): Promise<PathRow | undefined>;
-    /** Under another parent, or at the top, in every locale at once. Answers the page's rows. */
+    /**
+     * Under another parent, or at the top, with the slug it takes there in each of its locales:
+     * `{ en: 'team', fr: 'equipe' }`. Answers the page's rows.
+     */
     moveUnder(args: {
         slug: PrototypeSlug;
         ownerId: string;
         parentId: string | null;
+        slugs: Record<string, string>;
     }): Promise<PathRow[]>;
-    /** Its children go to the top, before it is deleted. Answers their rows. */
-    detachChildren(args: {
+    /** The pages directly under this one, in any locale. */
+    children(args: {
         slug: PrototypeSlug;
         ownerId: string;
-    }): Promise<PathRow[]>;
+    }): Promise<string[]>;
     /** The row at `path` and, with `withDescendants`, every row below it, in one locale. */
     under(args: {
         slug: PrototypeSlug;

package/dist/core/boot.server.d.ts

@@ -22,13 +22,13 @@ export declare const bootRime: <const C extends Config>(config: BuildConfig<C>)
         } ? { [K in NonNullable<C["areas"]>[number] as K extends {
             slug: infer N;
         } ? N extends string ? N : never : never]: K; } : Record<string, never>;
-        readonly prototypes: (import("./config/types.js").BuiltCollection | import("./config/types.js").BuiltArea)[];
+        readonly prototypes: (import("./config/types.js").BuiltArea | import("./config/types.js").BuiltCollection)[];
         getDefaultLocale(): string | undefined;
         getLocalesCodes: () => string[];
         isValidLocale: (locale: string) => boolean;
         getArea: (slug: string) => import("./config/types.js").BuiltArea;
         getCollection: (slug: string) => import("./config/types.js").BuiltCollection;
-        getBySlug: (slug: string) => import("./config/types.js").BuiltCollection | import("./config/types.js").BuiltArea;
+        getBySlug: (slug: string) => import("./config/types.js").BuiltArea | import("./config/types.js").BuiltCollection;
         isCollection: (slug?: string) => slug is import("./prototype/types.js").CollectionSlug;
         isArea: (slug?: string) => slug is import("./prototype/types.js").AreaSlug;
         getDocumentPrototype(slug: import("./prototype/types.js").PrototypeSlug): "area" | "collection";

package/dist/core/config/context.server.d.ts

@@ -42,7 +42,7 @@ export declare function createConfigContext<const C extends Config>(config: Buil
     /**
      * Gets every built prototype config, whatever its kind
      */
-    readonly prototypes: (import("../../types.js").BuiltCollection | import("../../types.js").BuiltArea)[];
+    readonly prototypes: (import("../../types.js").BuiltArea | import("../../types.js").BuiltCollection)[];
     /**
      * Gets the default locale from the configuration
      */
@@ -66,7 +66,7 @@ export declare function createConfigContext<const C extends Config>(config: Buil
     /**
      * Retrieves either an area or collection configuration by its slug
      */
-    getBySlug: (slug: string) => import("../../types.js").BuiltCollection | import("../../types.js").BuiltArea;
+    getBySlug: (slug: string) => import("../../types.js").BuiltArea | import("../../types.js").BuiltCollection;
     /**
      * Checks if a slug represents a collection
      */

package/dist/core/dev/codegen/routes/common.server.d.ts

@@ -33,3 +33,5 @@ declare const paramMatcher: (slugs: string[]) => string;
 declare const customRoute: (config: any) => string;
 export declare const commonRoutes: Routes;
 export { customRoute, paramMatcher, prototypeApiServer };
+/** Every fixed route file as the templates write it: a template that changes regenerates them. */
+export declare const templatesSurface: () => string;

package/dist/core/dev/codegen/routes/common.server.js

@@ -90,7 +90,7 @@ export const load = async ({ locals }: ServerLoadEvent) => {
  */
 const signInPage = () => `
 <script>
-  import { SignIn } from '${PACKAGE_NAME}/panel';
+  import { SignIn } from '${PACKAGE_NAME}/panel/public';
   const { data } = $props();
 </script>
 
@@ -113,7 +113,7 @@ export const actions = {
  */
 const forgotPasswordPage = () => `
 <script>
-  import { ForgotPassword } from '${PACKAGE_NAME}/panel'
+  import { ForgotPassword } from '${PACKAGE_NAME}/panel/public'
   const { data } = $props();
 </script>
 <ForgotPassword {data} />`;
@@ -132,7 +132,7 @@ export const load = (event: ServerLoadEvent) => event.locals.routes.panel.load.f
  */
 const resetPasswordPage = () => `
 <script>
-  import { ResetPassword } from '${PACKAGE_NAME}/panel';
+  import { ResetPassword } from '${PACKAGE_NAME}/panel/public';
   const { data } = $props();
 </script>
 
@@ -435,3 +435,7 @@ export const commonRoutes = {
     }
 };
 export { customRoute, paramMatcher, prototypeApiServer };
+/** Every fixed route file as the templates write it: a template that changes regenerates them. */
+export const templatesSurface = () => Object.entries(commonRoutes)
+    .flatMap(([pattern, files]) => Object.entries(files).map(([type, render]) => `${pattern}/${type}:${render()}`))
+    .join('\n');

package/dist/core/dev/codegen/routes/util.server.d.ts

@@ -16,7 +16,8 @@ export type Routes = Record<string, RouteDefinition>;
  * custom, css     written straight from config.panel
  * prototypes      the slug lists the [slug=<name>] matchers accept
  * rest            one +server.ts per prototype route path, and the methods it exports
- * version         the templates every file above is written from ship with the package
+ * templates       the fixed files as the package's templates write them today
+ * version         the package the templates ship with
  * ```
  *
  * `PANEL_ROUTE` and `CONFIG_DIR` are read once at process start, so a changed value only takes

package/dist/core/dev/codegen/routes/util.server.js

@@ -6,6 +6,7 @@ import { PANEL_ROUTE } from '../../../routes/constants.server.js';
 import { slugify } from '../../../../util/string.js';
 import fs from 'fs';
 import path from 'path';
+import { templatesSurface } from './common.server.js';
 /**
  * Whether the generated route tree still matches what the config and the package would produce.
  *
@@ -17,7 +18,8 @@ import path from 'path';
  * custom, css     written straight from config.panel
  * prototypes      the slug lists the [slug=<name>] matchers accept
  * rest            one +server.ts per prototype route path, and the methods it exports
- * version         the templates every file above is written from ship with the package
+ * templates       the fixed files as the package's templates write them today
+ * version         the package the templates ship with
  * ```
  *
  * `PANEL_ROUTE` and `CONFIG_DIR` are read once at process start, so a changed value only takes
@@ -39,6 +41,7 @@ export function shouldRegenerateRoutes(config) {
         .map((p) => `${p.type}:${p.slug}`)
         .join(',')}
     rest:${restSurface()}
+    templates:${templatesSurface()}
     version:${rimeVersion()}
   `;
     if (cache.matches('routes', memo))

package/dist/core/dev/config-memo.server.js

@@ -2,6 +2,7 @@ import { flatten } from 'flat';
 import cache from './cache.server.js';
 import { CONFIG_DIR } from './constants.server.js';
 import { restSurface } from './prototype-routes.server.js';
+import { templatesSurface } from './codegen/routes/common.server.js';
 import { rimeVersion } from './version.server.js';
 /**
  * We actually need to serialize config values that will trigger
@@ -76,6 +77,9 @@ const writeMemo = (config) => {
         // `generateRoutes` included, so a route added to a prototype has to move it — a version bump
         // does not, inside this repo, and the config never mentions those paths at all.
         .concat(`REST_SURFACE:${restSurface()}`)
+        // Nor are the route templates, which change inside this repo and between two packs of one
+        // version: the routes they write must follow.
+        .concat(`ROUTE_TEMPLATES:${templatesSurface()}`)
         .join('\n');
     if (cache.matches('config', memoStr))
         return false;

package/dist/core/prototype/collection/operations/duplicate.js

@@ -1,5 +1,5 @@
 import { copyLocales } from '../../../locale/copy.server.js';
-import { isJSONContent, richTextJSONToText } from '../../../../fields/rich-text/index.js';
+import { isJSONContent, richTextJSONToText } from '../../../../fields/rich-text/json.js';
 import { getValueAtPath, isObjectLiteral, setValueAtPath } from '../../../../util/object.js';
 // If block is localized should not keep its id so it created a new one
 // If block is not localized than it should keep its id so block is updated

package/dist/core/prototype/collection/thumbnail/hooks/set-document-thumbnail.server.js

@@ -1,5 +1,5 @@
 import { Hooks } from '../../../../pipeline/define-hook.js';
-import { isRelationResolved } from '../../../../../fields/relation/index.js';
+import { isRelationResolved } from '../../../../../fields/relation/util.js';
 import {} from '../../../../../types.js';
 import { getValueAtPath } from '../../../../../util/object.js';
 /**

package/dist/core/prototype/shared/title/hooks/set-document-title.server.js

@@ -1,5 +1,5 @@
 import { Hooks } from '../../../../pipeline/define-hook.js';
-import { richTextJSONToText } from '../../../../../fields/rich-text/index.js';
+import { richTextJSONToText } from '../../../../../fields/rich-text/json.js';
 import { getValueAtPath, isObjectLiteral } from '../../../../../util/object.js';
 /**
  * Puts `title` on the document, read from whichever field `asTitle` resolved to.

package/dist/core/prototype/shared/url/addresses.server.d.ts

@@ -9,6 +9,16 @@ export declare const addAddresses: (args: {
     config: BuiltCollection;
     ids: string[];
 }) => Promise<void>;
+/**
+ * Moves a page and its subtree under `parentId`, or to the top when it is null. In each locale the
+ * page keeps its slug, or takes the next free one when a new sibling holds it: `team`, `team-2`.
+ */
+export declare const movePage: (args: {
+    event: RequestEvent;
+    config: BuiltCollection;
+    ownerId: string;
+    parentId: string | null;
+}) => Promise<any>;
 /**
  * The document with its address as it now is: the read that produced it ran before a create or an
  * update gave it one.

package/dist/core/prototype/shared/url/addresses.server.js

@@ -1,6 +1,4 @@
-import { walkFields } from '../../../fields/walk.js';
 import { logger } from '../../../logger.server.js';
-import { getValueAtPath } from '../../../../util/object.js';
 import { hasUrl } from './enabled.js';
 import { freeSlug, toSlug } from './format.server.js';
 import { formatRows, readForUrls } from './refresh.server.js';
@@ -9,20 +7,8 @@ export const addressLocales = (event) => {
     const codes = event.locals.rime.config.getLocalesCodes();
     return codes.length ? codes : [''];
 };
-/**
- * The slug a page starts with: the collection's own slug field when it has one, its title
- * otherwise, its id as a last resort.
- */
-const initialSlug = (config, doc) => {
-    for (const { field, path } of walkFields(config.fields)) {
-        if (field.type !== 'slug')
-            continue;
-        const value = toSlug(getValueAtPath(path, doc));
-        if (value)
-            return value;
-    }
-    return toSlug(doc.title) || doc.id;
-};
+/** The slug a page starts with: its title, its id as a last resort. */
+const initialSlug = (doc) => toSlug(doc.title) || doc.id;
 /**
  * Gives these pages their address in one locale: a slug free among their siblings, under their
  * parent, then their url.
@@ -43,7 +29,7 @@ const addAddressesIn = async (args) => {
         for (const id of ready) {
             const parentId = parentOf(id);
             const taken = await paths.siblingSlugs({ slug: config.slug, locale, parentId });
-            const slug = freeSlug(initialSlug(config, docs.get(id)), taken);
+            const slug = freeSlug(initialSlug(docs.get(id)), taken);
             inserted.push(...(await paths.insert({
                 slug: config.slug,
                 ownerId: id,
@@ -70,6 +56,20 @@ export const addAddresses = async (args) => {
             await addAddressesIn({ event, config, ids: idsHere, locale });
     }
 };
+/**
+ * Moves a page and its subtree under `parentId`, or to the top when it is null. In each locale the
+ * page keeps its slug, or takes the next free one when a new sibling holds it: `team`, `team-2`.
+ */
+export const movePage = async (args) => {
+    const { event, config, ownerId, parentId } = args;
+    const { paths } = event.locals.rime.adapter;
+    const slugs = {};
+    for (const row of await paths.get({ slug: config.slug, ownerId })) {
+        const taken = await paths.siblingSlugs({ slug: config.slug, locale: row.locale, parentId });
+        slugs[row.locale] = freeSlug(row.slug, taken);
+    }
+    return paths.moveUnder({ slug: config.slug, ownerId, parentId, slugs });
+};
 /**
  * The document with its address as it now is: the read that produced it ran before a create or an
  * update gave it one.

package/dist/core/prototype/shared/url/hooks/detach-paths.server.d.ts

@@ -1,5 +1,6 @@
 /**
- * Before a delete, the page's children go to the top level with their subtrees, as `_parent`
- * does, and get their new urls. The page's own rows go with it by cascade.
+ * Before a delete, the page's children go to the top with their subtrees, as `_parent` does, and
+ * get their new urls. A child whose slug a top page holds takes the next free one. The page's own
+ * rows go with it by cascade.
  */
 export declare const detachPaths: import("../../../../pipeline/types.js").Hook<"generic", "delete", "before">;

package/dist/core/prototype/shared/url/hooks/detach-paths.server.js

@@ -1,18 +1,19 @@
 import { Hooks } from '../../../../pipeline/define-hook.js';
+import { movePage } from '../addresses.server.js';
 import { refreshUrls } from '../refresh.server.js';
 /**
- * Before a delete, the page's children go to the top level with their subtrees, as `_parent`
- * does, and get their new urls. The page's own rows go with it by cascade.
+ * Before a delete, the page's children go to the top with their subtrees, as `_parent` does, and
+ * get their new urls. A child whose slug a top page holds takes the next free one. The page's own
+ * rows go with it by cascade.
  */
 export const detachPaths = Hooks.beforeDelete(async function detachPaths(args) {
     const { event, doc } = args;
     const config = args.config;
-    const detached = await event.locals.rime.adapter.paths.detachChildren({
-        slug: config.slug,
-        ownerId: doc.id
-    });
-    for (const row of detached) {
-        await refreshUrls({ event, config, locale: row.locale, path: row.path });
+    const { paths } = event.locals.rime.adapter;
+    for (const ownerId of await paths.children({ slug: config.slug, ownerId: doc.id })) {
+        for (const row of await movePage({ event, config, ownerId, parentId: null })) {
+            await refreshUrls({ event, config, locale: row.locale, path: row.path });
+        }
     }
     return args;
 });

package/dist/core/prototype/shared/url/hooks/sync-paths.server.d.ts

@@ -1,6 +1,7 @@
 /**
- * After a save. A move carries the page and its subtree under the new parent, in every locale at
- * once. Any other save formats the page's own urls again, since `$url` may read any of its fields.
+ * After a save. A move carries the page and its subtree under the new parent, in every locale,
+ * with a free slug there. Any other save formats the page's own urls again, since `$url` may read
+ * any of its fields.
  *
  * An auto-save moves nothing and changes no url: it is skipped.
  */

package/dist/core/prototype/shared/url/hooks/sync-paths.server.js

@@ -1,10 +1,11 @@
 import { Hooks } from '../../../../pipeline/define-hook.js';
 import { isNested } from '../../../collection/nested/enabled.js';
-import { addAddresses, withAddress } from '../addresses.server.js';
+import { addAddresses, movePage, withAddress } from '../addresses.server.js';
 import { refreshUrls } from '../refresh.server.js';
 /**
- * After a save. A move carries the page and its subtree under the new parent, in every locale at
- * once. Any other save formats the page's own urls again, since `$url` may read any of its fields.
+ * After a save. A move carries the page and its subtree under the new parent, in every locale,
+ * with a free slug there. Any other save formats the page's own urls again, since `$url` may read
+ * any of its fields.
  *
  * An auto-save moves nothing and changes no url: it is skipped.
  */
@@ -18,7 +19,7 @@ export const syncPaths = Hooks.afterUpdate(async function syncPaths(args) {
     const wasUnder = context.originalDoc?._parent ?? null;
     const moved = isNested(config) && parentId !== wasUnder;
     const rows = moved
-        ? await paths.moveUnder({ slug: config.slug, ownerId: doc.id, parentId })
+        ? await movePage({ event, config, ownerId: doc.id, parentId })
         : await paths.get({ slug: config.slug, ownerId: doc.id });
     // A page saved before it had an address gets one.
     if (!rows.length) {

package/dist/fields/blocks/component/focus/BlocksFocus.svelte

@@ -10,7 +10,7 @@
   import type { DocumentFormContext } from '../../../../panel/context/documentForm.svelte.js';
   import { getLocaleContext } from '../../../../panel/context/locale.svelte.js';
   import { getNavContext } from '../../../../panel/context/nav.svelte.js';
-  import { populate } from '../../../../panel/util/populate.js';
+  import { populate } from '../../../relation/populate.js';
   import { capitalize } from '../../../../util/string.js';
   import { ChevronRight, PanelRight, ToyBrick, X } from '@lucide/svelte';
   import { untrack } from 'svelte';

package/dist/fields/link/index.d.ts

@@ -56,7 +56,7 @@ export declare class LinkFieldBuilder extends FormFieldBuilder<LinkField> {
         root?: boolean | undefined;
         index?: boolean | undefined;
         layout: "compact" | "default";
-        types: "tel"[] | "email"[] | "url"[] | "anchor"[];
+        types: "url"[] | "email"[] | "tel"[] | "anchor"[];
     } & {
         component: import("svelte").Component<any>;
         cell?: import("svelte").Component<{

package/dist/fields/relation/component/RelationInline.svelte

@@ -9,7 +9,7 @@
   import { getConfigContext } from '../../../panel/context/config.svelte.js';
   import type { DocumentFormContext } from '../../../panel/context/documentForm.svelte.js';
   import { getLocaleContext } from '../../../panel/context/locale.svelte.js';
-  import { populate } from '../../../panel/util/populate.js';
+  import { populate } from '../populate.js';
   import { uploadFiles, type UploadProgress } from '../../../panel/util/upload-file.js';
   import { Image as ImageIcon } from '@lucide/svelte';
   import type { Snippet } from 'svelte';

package/dist/fields/relation/index.d.ts

@@ -1,7 +1,7 @@
 import type { DataType } from '../../core/fields/builders/form-field-builder.js';
 import { FormFieldBuilder } from '../../core/fields/builders/form-field-builder.js';
 import type { CollectionSlug, GenericDoc } from '../../core/prototype/types.js';
-import type { DefaultValueFn, FormField, RelationRef, RelationValue } from '../types.js';
+import type { DefaultValueFn, FormField } from '../types.js';
 import type { RegisterCollection } from '../../index.js';
 import type { WithOptional } from '../../util/types.js';
 export declare class RelationFieldBuilder<Doc extends GenericDoc = GenericDoc> extends FormFieldBuilder<RelationField<Doc>> {
@@ -29,46 +29,6 @@ export declare class RelationFieldBuilder<Doc extends GenericDoc = GenericDoc> e
     protected generateType(): string;
 }
 export declare const relation: (name: string) => RelationFieldBuilder<GenericDoc>;
-/**
- * Checks if a relation value is resolved (contains the actual referenced document).
- *
- * @example
- * // Returns true for a resolved relation
- * isRelationResolved({ title: 'Home Page', _prototype: 'collection', _type: 'pages' });
- */
-export declare const isRelationResolved: <T>(value: any) => value is T;
-/**
- * Checks if a relation value is a reference (contains only the relationTo and documentId).
- *
- * @example
- * // Returns true for a relation reference
- * isRelationRef({ relationTo: 'pages', documentId: '123' });
- */
-export declare const isRelationRef: (value: unknown) => value is RelationRef;
-/**
- * Checks if a relation value is unresolved (contains only reference information).
- *
- * @example
- * // Returns true for an unresolved relation
- * isRelationUnresolved({ relationTo: 'pages', documentId: '123' });
- */
-export declare const isRelationUnresolved: (value: any) => value is Omit<Relation, "path" | "position" | "ownerId">;
-/**
- * Resolves a relation reference to the actual document it points to.
- *
- * @example
- * // Resolves a relation reference to the actual document
- * const doc = await resolveRelationRef({ relationTo: 'pages', documentId: '123' });
- */
-export declare function resolveRelationRef<T>(item: T | RelationRef | string): Promise<T>;
-/**
- * Resolves a relation field value to the actual documents it points to.
- *
- * @example
- * // Resolves a relation value to the actual documents
- * const docs = await resolveRelation([{ relationTo: 'pages', documentId: '123' }]);
- */
-export declare function resolveRelation<T>(value: RelationValue<T> | null | undefined): Promise<T[] | null | undefined>;
 /****************************************************/
 export type RelationField<Doc extends GenericDoc = GenericDoc> = FormField & {
     type: 'relation';