@verdant-web/common 2.3.0-next.0 → 2.3.1

package/dist/esm/schema/types/synthetics.d.ts

@@ -0,0 +1,37 @@
+import { StorageBooleanFieldSchema, StorageFieldsSchema, StorageNumberFieldSchema, StorageStringFieldSchema } from './fields.js';
+import { ShapeFromFields } from './shapes.js';
+export type StorageStringSyntheticSchema<Fields extends StorageFieldsSchema> = {
+    type: 'string';
+    compute: (value: ShapeFromFields<Fields>) => string | null;
+};
+export type StorageNumberSyntheticSchema<Fields extends StorageFieldsSchema> = {
+    type: 'number';
+    compute: (value: ShapeFromFields<Fields>) => number | null;
+};
+export type StorageBooleanSyntheticSchema<Fields extends StorageFieldsSchema> = {
+    type: 'boolean';
+    compute: (value: ShapeFromFields<Fields>) => boolean | null;
+};
+export type StorageStringArraySyntheticSchema<Fields extends StorageFieldsSchema> = {
+    type: 'string[]';
+    compute: (value: ShapeFromFields<Fields>) => string[];
+};
+export type StorageNumberArraySyntheticSchema<Fields extends StorageFieldsSchema> = {
+    type: 'number[]';
+    compute: (value: ShapeFromFields<Fields>) => number[];
+};
+export type StorageBooleanArraySyntheticSchema<Fields extends StorageFieldsSchema> = {
+    type: 'boolean[]';
+    compute: (value: ShapeFromFields<Fields>) => boolean[];
+};
+export type StorageDirectSyntheticSchema<Fields extends StorageFieldsSchema> = {
+    field: DirectIndexableFieldName<Fields>;
+};
+type DirectIndexableFields<Fields extends StorageFieldsSchema> = {
+    [K in keyof Fields as Fields[K] extends StorageStringFieldSchema ? K : Fields[K] extends StorageNumberFieldSchema ? K : Fields[K] extends StorageBooleanFieldSchema ? K : never]: any;
+};
+export type DirectIndexableFieldName<Fields extends StorageFieldsSchema> = keyof DirectIndexableFields<Fields> extends never ? string : keyof DirectIndexableFields<Fields>;
+export type StorageSyntheticIndices<Fields extends StorageFieldsSchema> = Record<string, StorageSyntheticIndexSchema<Fields>>;
+export type StorageSyntheticIndexSchema<Fields extends StorageFieldsSchema> = StorageStringSyntheticSchema<Fields> | StorageNumberSyntheticSchema<Fields> | StorageBooleanSyntheticSchema<Fields> | StorageStringArraySyntheticSchema<Fields> | StorageNumberArraySyntheticSchema<Fields> | StorageBooleanArraySyntheticSchema<Fields> | StorageDirectSyntheticSchema<Fields>;
+export type IndexValueTag = Exclude<StorageSyntheticIndexSchema<any>, StorageDirectSyntheticSchema<any>>['type'];
+export {};

package/dist/esm/schema/types.d.ts

@@ -0,0 +1,18 @@
+import { StorageCollectionSchema } from './types/collection.js';
+export * from './types/collection.js';
+export * from './types/compounds.js';
+export * from './types/fields.js';
+export * from './types/filters.js';
+export * from './types/shapes.js';
+export * from './types/synthetics.js';
+export type StorageSchema<Collections extends {
+    [k: string]: StorageCollectionSchema;
+} = {
+    [k: string]: StorageCollectionSchema;
+}> = {
+    version: number;
+    wip?: true;
+    collections: Collections;
+};
+export type SchemaCollectionName<Schema extends StorageSchema<any>> = Schema extends StorageSchema<infer Cs> ? Exclude<keyof Cs, number | symbol> : never;
+export type SchemaCollection<Schema extends StorageSchema<any>, Name extends SchemaCollectionName<Schema>> = Schema extends StorageSchema<infer Cs> ? Cs[Name] : never;

package/dist/esm/schema/validation.d.ts

@@ -0,0 +1,14 @@
+import { StorageFieldSchema, StorageFieldsSchema } from './types.js';
+export declare function validateEntity(schema: StorageFieldsSchema, entity: any): EntityValidationProblem | void;
+export type EntityValidationProblem = {
+    type: 'null' | 'no-default' | 'invalid-type' | 'invalid-value' | 'invalid-key';
+    fieldPath: (string | number)[];
+    message: string;
+};
+export declare function validateEntityField({ field, value, fieldPath, depth, requireDefaults, }: {
+    field: StorageFieldSchema;
+    value: any;
+    fieldPath: (string | number)[];
+    depth?: number;
+    requireDefaults?: boolean;
+}): EntityValidationProblem | undefined;

package/dist/esm/timestamp.d.ts

@@ -0,0 +1,51 @@
+export interface TimestampProvider {
+    now(version: number): string;
+    update(remoteTimestamp: string): void;
+    zero(version: number): string;
+    getWallClockTime(timestamp: string): number;
+}
+export declare function encodeVersion(version: number | string): string;
+export declare function OLD_encodeVersion(version: number | string): string;
+export declare class NaiveTimestampProvider implements TimestampProvider {
+    counter: number;
+    now: (version: number | string) => string;
+    update: () => void;
+    zero: (version: number | string) => string;
+    getWallClockTime: (timestamp: string) => number;
+}
+export declare class HybridLogicalClockTimestampProvider implements TimestampProvider {
+    private latest;
+    private zeroCounter;
+    now: (version: string | number) => string;
+    /**
+     * @deprecated - use now() instead and update to latest format
+     */
+    OLD_now: (version: string | number) => string;
+    /** Get the current timer state. Does not increment counter. */
+    timerState: () => HLCTimestamp;
+    update: (remoteTimestamp: string) => void;
+    get: (version: string | number, raw: HLCTimestamp) => string;
+    zero: (version: string | number) => string;
+    getWallClockTime: typeof getWallClockTime;
+}
+interface HLCTimestamp {
+    time: number;
+    counter: number;
+    node: string;
+}
+export declare function serializeHlcTimestamp(ts: HLCTimestamp): string;
+export declare function deserializeHlcTimestamp(clock: string): HLCTimestamp;
+/**
+ * Below, converters for old-style timestamps are defined.
+ * These are for migrating older clients to the new format.
+ */
+/**
+ * Converts a timestamp from the old format to the new format.
+ */
+export declare function convertOldHlcTimestamp(ts: string): string;
+export declare function OLD_serializeHlcTimestamp(ts: HLCTimestamp): string;
+export declare function OLD_deserializeHlcTimestamp(clock: string): HLCTimestamp;
+export declare function getTimestampSchemaVersion(timestamp: string): number;
+export declare function compareTimestampSchemaVersions(a: string, b: string): number;
+export declare function getWallClockTime(timestamp: string): number;
+export {};

package/dist/esm/timestamp.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/esm/undo.d.ts

@@ -0,0 +1,3 @@
+import { ObjectIdentifier } from './oids.js';
+import { Operation } from './operation.js';
+export declare function getUndoOperations(oid: ObjectIdentifier, initial: any, operations: Operation[], getNow: () => string): Operation[];

package/dist/esm/utils.d.ts

@@ -0,0 +1,20 @@
+export declare function take<T extends object, Keys extends keyof T>(obj: T, keys: Keys[]): Pick<T, Keys>;
+export declare function omit<T extends object, Keys extends keyof T>(obj: T, keys: Keys[]): Omit<T, Keys>;
+export declare function getSortedIndex<T>(array: T[], insert: T, compare: (a: T, b: T) => number): number;
+/**
+ * Consistently stringifies an object regardless
+ * of key insertion order
+ */
+export declare function stableStringify(obj: any): string;
+/**
+ * A version of structured cloning which preserves object identity
+ * references in the system.
+ */
+export declare function cloneDeep<T>(obj: T, copyOids?: boolean): T;
+export declare function hashObject(obj: any): string;
+export declare function isObject(obj: any): any;
+export declare function roughSizeOfObject(object: any): number;
+export declare function assert(condition: any, message?: string): asserts condition;
+export declare function generateId(length?: number): string;
+export declare function findLastIndex<T>(array: T[], predicate: (item: T) => boolean): number;
+export declare function debounce<T extends (...args: any[]) => any>(fn: T, wait: number): T;

package/dist/esm/utils.test.d.ts

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@verdant-web/common",
-  "version": "2.3.0-next.0",
+  "version": "2.3.1",
   "access": "public",
   "type": "module",
   "exports": {

package/src/oids.ts

@@ -12,22 +12,16 @@ import { isObject, assert } from './utils.js';
  * on its own and associating it back to its parent.
  *
  * An OID is structured as such:
- * <collection>/<root id>[/<key paths>]:<random>
+ * <collection>/<root id>:<random>
  *
  * OIDs have a few characteristics:
  * - They include the collection name of the parent document
  * - They include the primary key of the parent document
- * - They include the key path of the object within the document
- * - They include a random sequence to identify different objects which
- *   exist at the same key path
+ * - They may include a random sequence to identify sub-objects
  *
  * Collection name and document key are used to link any isolated
  * object back to its parent document.
  *
- * The key path is used for authorization - to associate the object
- * (or an operation related to it by OID) with the field it inhabits
- * to utilize authorization rules from that field in the schema.
- *
  * The random sequence allows the application to encode different
  * identities for objects at the same position in a document for
  * conflict resolution purposes
@@ -127,7 +121,7 @@ export function ensureCompatibleOid(
 	}
 }
 
-const SANTIIZE_PLACEHOLDERS = {
+const SANITIZE_PLACEHOLDERS = {
 	'.': '&dot;',
 	'/': '&slash;',
 	':': '&colon;',
@@ -135,9 +129,9 @@ const SANTIIZE_PLACEHOLDERS = {
 function sanitizeFragment(id: string) {
 	// replaces separator characters with placeholders
 	return id
-		.replace(/[/]/g, SANTIIZE_PLACEHOLDERS['/'])
-		.replace(/[:]/g, SANTIIZE_PLACEHOLDERS[':'])
-		.replace(/[.]/g, SANTIIZE_PLACEHOLDERS['.']);
+		.replace(/[/]/g, SANITIZE_PLACEHOLDERS['/'])
+		.replace(/[:]/g, SANITIZE_PLACEHOLDERS[':'])
+		.replace(/[.]/g, SANITIZE_PLACEHOLDERS['.']);
 }
 function unsanitizeFragment(id: string) {
 	// replaces placeholders with separator characters