@verdant-web/store 2.8.5 → 3.0.0-next.0

package/dist/cjs/entities/2/Entity.d.ts

@@ -0,0 +1,148 @@
+import { EntityValidationProblem, EventSubscriber, ObjectIdentifier, PatchCreator, StorageFieldSchema } from '@verdant-web/common';
+import { Context } from '../../context.js';
+import { FileManager } from '../../files/FileManager.js';
+import { EntityCache } from './EntityCache.js';
+import { EntityFamilyMetadata, EntityMetadataView } from './EntityMetadata.js';
+import { BaseEntityValue, DataFromInit, DeepPartial, EntityChange, EntityEvents, ListEntity, ListItemInit, ListItemValue, ObjectEntity } from './types.js';
+import { EntityStoreEvents } from './EntityStore.js';
+export interface EntityInit {
+    oid: ObjectIdentifier;
+    schema: StorageFieldSchema;
+    entityFamily?: EntityCache;
+    metadataFamily: EntityFamilyMetadata;
+    parent?: Entity;
+    ctx: Context;
+    files: FileManager;
+    readonlyKeys?: string[];
+    fieldPath?: (string | number)[];
+    patchCreator: PatchCreator;
+    events: EntityStoreEvents;
+}
+export declare class Entity<Init = any, KeyValue extends BaseEntityValue = any, Snapshot extends any = DataFromInit<Init>> extends EventSubscriber<EntityEvents> implements ObjectEntity<Init, KeyValue, Snapshot>, ListEntity<Init, KeyValue, Snapshot> {
+    readonly oid: ObjectIdentifier;
+    private readonlyKeys;
+    private fieldPath;
+    private entityFamily;
+    private metadataFamily;
+    private schema;
+    private parent;
+    private ctx;
+    private files;
+    private patchCreator;
+    private events;
+    private _viewData;
+    private validationError;
+    private cachedDeepUpdatedAt;
+    private wasDeletedLastChange;
+    private cachedView;
+    constructor({ oid, schema, entityFamily: childCache, parent, ctx, metadataFamily, readonlyKeys, files, patchCreator, events, }: EntityInit);
+    private onAdd;
+    private onReplace;
+    private onResetAll;
+    private get metadata();
+    /**
+     * The view of this Entity, not including nested
+     * entities (that's the snapshot - see #getSnapshot())
+     *
+     * Nested entities are represented by refs.
+     */
+    private get viewData();
+    /** convenience getter for viewData.view */
+    private get rawView();
+    /**
+     * An Entity's View includes the rendering of its underlying data,
+     * connecting of children where refs were, and validation
+     * and pruning according to schema.
+     */
+    private get view();
+    private childIsNull;
+    get uid(): string;
+    get deleted(): boolean;
+    get invalid(): boolean;
+    get isList(): any;
+    get updatedAt(): number;
+    get deepUpdatedAt(): number;
+    /**
+     * @internal - this is relevant to Verdant's system, not users.
+     *
+     * Indicates whether this document is from an outdated version
+     * of the schema - which means it cannot be used until it is upgraded.
+     */
+    get isOutdatedVersion(): boolean;
+    /**
+     * Pruning - when entities have invalid children, we 'prune' that
+     * data up to the nearest prunable point - a nullable field,
+     * or a list.
+     */
+    protected validate: (...args: unknown[]) => EntityValidationProblem | undefined;
+    private viewWithMappedChildren;
+    /**
+     * A current snapshot of this Entity's data, including nested
+     * Entities.
+     */
+    getSnapshot: () => any;
+    private addPendingOperations;
+    private addConfirmedData;
+    private replaceAllData;
+    private resetAllData;
+    private change;
+    protected deepChange: (target: Entity, ev: EntityChange) => void;
+    private getChild;
+    /**
+     * Gets a value from this Entity. If the value
+     * is an object, it will be wrapped in another
+     * Entity.
+     */
+    get: <Key extends keyof KeyValue>(key: Key) => KeyValue[Key];
+    private processInputValue;
+    private getDeleteMode;
+    /**
+     * Returns the referent value of an item in the list, used for
+     * operations which act on items. if the item is an object,
+     * it will attempt to create an OID reference to it. If it
+     * is a primitive, it will return the primitive.
+     */
+    private getItemRefValue;
+    set: <Key extends keyof Init>(key: Key, value: Init[Key]) => void;
+    /**
+     * Returns a destructured version of this Entity, where child
+     * Entities are accessible at their respective keys.
+     */
+    getAll: () => KeyValue;
+    delete: (key: any) => void;
+    keys: () => string[];
+    entries: () => [string, Exclude<KeyValue[keyof KeyValue], undefined>][];
+    values: () => Exclude<KeyValue[keyof KeyValue], undefined>[];
+    update: (data: DeepPartial<Init>, { merge, replaceSubObjects, }?: {
+        replaceSubObjects?: boolean | undefined;
+        merge?: boolean | undefined;
+    }) => void;
+    get length(): number;
+    push: (value: ListItemInit<Init>) => void;
+    insert: (index: number, value: ListItemInit<Init>) => void;
+    move: (from: number, to: number) => void;
+    moveItem: (item: ListItemValue<KeyValue>, to: number) => void;
+    add: (value: ListItemValue<KeyValue>) => void;
+    removeAll: (item: ListItemValue<KeyValue>) => void;
+    removeFirst: (item: ListItemValue<KeyValue>) => void;
+    removeLast: (item: ListItemValue<KeyValue>) => void;
+    [Symbol.iterator](): {
+        next: () => {
+            readonly value: ListItemValue<KeyValue>;
+            readonly done: false;
+        } | {
+            readonly value: undefined;
+            readonly done: true;
+        };
+    };
+    map: <U>(callback: (value: ListItemValue<KeyValue>, index: number) => U) => U[];
+    filter: (callback: (value: ListItemValue<KeyValue>, index: number) => boolean) => ListItemValue<KeyValue>[];
+    has: (value: ListItemValue<KeyValue>) => boolean;
+    forEach: (callback: (value: ListItemValue<KeyValue>, index: number) => void) => void;
+    some: (predicate: (value: ListItemValue<KeyValue>) => boolean) => boolean;
+    every: (predicate: (value: ListItemValue<KeyValue>) => boolean) => boolean;
+    find: (predicate: (value: ListItemValue<KeyValue>) => boolean) => ListItemValue<KeyValue> | undefined;
+    includes: (value: ListItemValue<KeyValue>) => boolean;
+    __getViewData__: (oid: ObjectIdentifier, type: 'confirmed' | 'pending') => EntityMetadataView;
+    __getFamilyOids__: () => string[];
+}