Skip to content
Closed
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
4 changes: 4 additions & 0 deletions CHANGELOG.md
Original file line number Diff line number Diff line change
Expand Up @@ -16,6 +16,10 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),

### Breaking Changes

- Legacy rich-text refs (`RefMarker` leaves or `RefNode` elements) now throw
on read, normalize, and serialize instead of being silently stripped. Back up
the store first. Use a release that supports legacy refs to migrate affected
data, or remove that data and re-sync it from a peer.
- `coreValueHash` alias removed. Use `encodableValueHash`.
- Clone aliasing: `coreValueClone`/`coreObjectClone` now preserve shared-ref
aliasing across array/set siblings. Aliases within object fields were already
Expand Down
49 changes: 16 additions & 33 deletions cfds/base/types/core-type.ts
Original file line number Diff line number Diff line change
@@ -1,13 +1,17 @@
import { IValueTypeOperations, ValueType, ValueTypeOptions } from './index.ts';
import { DecodedValue } from '../../../base/core-types/encoding/index.ts';
import { Change, EncodedChange } from '../../change/index.ts';
import type {
IValueTypeOperations,
ValueType,
ValueTypeOptions,
} from './index.ts';
import type { DecodedValue } from '../../../base/core-types/encoding/index.ts';
import type { Change, EncodedChange } from '../../change/index.ts';
import { FieldChange } from '../../change/field-change.ts';
import {
ConcreteCoreValue,
CoreType,
type ConcreteCoreValue,
type CoreType,
coreValueClone,
coreValueEquals,
Encoder,
type Encoder,
getCoreTypeOrUndef,
} from '../../../base/core-types/index.ts';

Expand All @@ -30,13 +34,11 @@ export abstract class CoreTypeOperations<
return value;
}

fillRefs(refs: Set<string>, value: TValue): void {}

validate(value: any): boolean {
validate(value: unknown): boolean {
return getCoreTypeOrUndef(value) === this._coreType;
}

equals(val1: TValue, val2: TValue, options?: ValueTypeOptions): boolean {
equals(val1: TValue, val2: TValue, _options?: ValueTypeOptions): boolean {
return coreValueEquals(val1, val2);
}

Expand All @@ -48,48 +50,29 @@ export abstract class CoreTypeOperations<
key: string,
value: TValue,
encoder: Encoder,
options?: ValueTypeOptions,
_options?: ValueTypeOptions,
): void {
encoder.set(key, value);
}

deserialize(value: DecodedValue, options?: ValueTypeOptions) {
deserialize(value: DecodedValue, _options?: ValueTypeOptions) {
return value as TValue;
}

valueAddedDiff(
value2: TValue,
options?: ValueTypeOptions,
_options?: ValueTypeOptions,
): undefined | Change<EncodedChange> | Change<EncodedChange>[] {
return FieldChange.insert(value2, this._valueType);
}

valueRemovedDiff(
value1: TValue,
options?: ValueTypeOptions,
_options?: ValueTypeOptions,
): undefined | Change<EncodedChange> | Change<EncodedChange>[] {
return FieldChange.delete(value1, this._valueType);
}

needGC(value: TValue): boolean {
return false;
}

gc(value: TValue): TValue | undefined {
return undefined;
}

rewriteRefs(
keyMapping: Map<string, string>,
value: TValue,
deleteRefs?: Set<string>,
): TValue | undefined {
if (deleteRefs && deleteRefs.has(value as string)) {
return undefined;
}
return (keyMapping.get(value as string) as TValue) || value;
}

abstract valueChangedDiff(
value1: TValue,
value2: TValue,
Expand Down
80 changes: 19 additions & 61 deletions cfds/base/types/index.ts
Original file line number Diff line number Diff line change
@@ -1,17 +1,16 @@
import { DecodedValue } from '../../../base/core-types/encoding/index.ts';
import { Change, EncodedChange } from '../../change/index.ts';
import type { DecodedValue } from '../../../base/core-types/encoding/index.ts';
import type { ChecksumEncoderOpts } from '../../../base/core-types/encoding/checksum.ts';
import type { Change, EncodedChange } from '../../change/index.ts';
import { MapTypeOperations } from './map-type.ts';
import { PrimitiveTypeOperations } from './primitive-type.ts';
import { SetTypeOperations } from './set-type.ts';
import { StringTypeOperations } from './string-type.ts';
import { RichText3TypeOperations } from './richtext3-type.ts';
import {
CoreType,
CoreValue,
Encoder,
type CoreValue,
type Encoder,
} from '../../../base/core-types/index.ts';
import { DateTypeOperations } from './date-type.ts';
import { ChecksumEncoderOpts } from '../../../base/core-types/encoding/checksum.ts';

export type ValueType =
| 'string'
Expand Down Expand Up @@ -84,73 +83,32 @@ export interface IValueTypeOperations<T extends CoreValue = CoreValue> {
options?: ValueTypeOptions,
): T | undefined;

fillRefs(refs: Set<string>, value: T): void;

normalize(value: T): T;

isEmpty(value: T): boolean;

needGC(value: T): boolean;
gc(value: T): T | undefined;

rewriteRefs(
keyMapping: Map<string, string>,
value: T,
deleteRefs?: Set<string>,
): T | undefined;
}

const registeredTypeOperations: Record<
string,
IValueTypeOperations<CoreValue>
> = {};
/** Every `ValueType` has exactly one op set. `satisfies` + `Object.freeze`
* make this exhaustive and immutable at compile time. */
const kTypeOperations = Object.freeze({
string: new PrimitiveTypeOperations(CoreType.String, 'string'),
number: new PrimitiveTypeOperations(CoreType.Number, 'number'),
boolean: new PrimitiveTypeOperations(CoreType.Boolean, 'boolean'),
date: new DateTypeOperations(),
set: new SetTypeOperations('set'),
map: new MapTypeOperations('map'),
richtext: new RichText3TypeOperations(),
}) satisfies Record<ValueType, IValueTypeOperations<CoreValue>>;

export function getTypeOperations<T extends CoreValue>(
type: ValueType,
): IValueTypeOperations<T> {
const op = registeredTypeOperations[type];
if (op === undefined) {
throw new Error(`type operations for: ${type} has not been implemented`);
}
// `kTypeOperations` satisfies Record<ValueType, ...>, so the lookup is total.
// Widen to the erased op type before narrowing to `T` (TS needs the step).
const op: IValueTypeOperations<CoreValue> = kTypeOperations[type];
return op as IValueTypeOperations<T>;
}

export function getTypeOperationsByValue<T extends CoreValue>(
value: T,
): IValueTypeOperations<T> {
for (const typeOP of Object.values(registeredTypeOperations)) {
if (typeOP.validate(value)) {
return typeOP as IValueTypeOperations<T>;
}
}

throw new Error(`getTypeOperationsByValue failed for: ${value}`);
}

registerTypeOperations();
function registerType<T extends CoreValue>(op: IValueTypeOperations<T>): void {
registeredTypeOperations[op.valueType] = op as IValueTypeOperations<
CoreValue
>;
}

function registerTypeOperations(): void {
if (Object.entries(registeredTypeOperations).length === 0) {
registerType(new StringTypeOperations(CoreType.String, 'string'));
registerType(new PrimitiveTypeOperations(CoreType.Number, 'number'));
registerType(new PrimitiveTypeOperations(CoreType.Boolean, 'boolean'));
registerType(new DateTypeOperations());
registerType(new SetTypeOperations(false, 'set'));
// registerType(new SetTypeOperations(false, 'stringset'));
// registerType(new SetTypeOperations(false, 'refset'));
registerType(new MapTypeOperations(false, 'map'));
// registerType(new MapTypeOperations(false, 'refmap'));
registerType(new RichText3TypeOperations());

//Add Types Here
}
}

export function valueTypeEquals<TValue>(
type: ValueType,
value1: TValue | undefined,
Expand Down
59 changes: 8 additions & 51 deletions cfds/base/types/map-type.ts
Original file line number Diff line number Diff line change
@@ -1,24 +1,24 @@
import { ValueType, ValueTypeOptions } from './index.ts';
import type { ValueType, ValueTypeOptions } from './index.ts';
import {
dictFromPrimitive,
Dictionary,
PrimitiveMap,
type Dictionary,
type PrimitiveMap,
} from '../../../base/collections/dict.ts';
import { DecodedValue } from '../../../base/core-types/encoding/index.ts';
import { Change, EncodedChange } from '../../change/index.ts';
import type { DecodedValue } from '../../../base/core-types/encoding/index.ts';
import type { Change, EncodedChange } from '../../change/index.ts';
import { CoreTypeOperations } from './core-type.ts';
import { FieldChange, FieldOperation } from '../../change/field-change.ts';
import {
ConcreteCoreValue,
CoreKey,
type ConcreteCoreValue,
type CoreKey,
CoreType,
coreValueEquals,
} from '../../../base/core-types/index.ts';

export class MapTypeOperations extends CoreTypeOperations<
Dictionary<CoreKey, ConcreteCoreValue>
> {
constructor(readonly isRef: boolean, valueType: ValueType) {
constructor(valueType: ValueType) {
super(CoreType.Dictionary, valueType);
}

Expand Down Expand Up @@ -131,47 +131,4 @@ export class MapTypeOperations extends CoreTypeOperations<
private createMap(): Dictionary {
return new Map();
}

override gc(
value: Dictionary<CoreKey, ConcreteCoreValue>,
): Dictionary<CoreKey, ConcreteCoreValue> | undefined {
return undefined;
}

override fillRefs(
refs: Set<string>,
dict: Dictionary<ConcreteCoreValue, ConcreteCoreValue>,
): void {
if (this.isRef && dict !== undefined) {
for (const [key, value] of dict) {
if (typeof key === 'string') {
refs.add(key);
}
if (typeof value === 'string') {
refs.add(value);
}
}
}
}

override rewriteRefs(
keyMapping: Map<string, string>,
dict: Dictionary<string, ConcreteCoreValue>,
deleteRefs?: Set<string>,
): Dictionary<string, ConcreteCoreValue> {
if (!this.isRef) {
return dict;
}
const result = new Map<string, ConcreteCoreValue>();
for (const [key, value] of dict) {
if (deleteRefs?.has(key) || deleteRefs?.has(value as string)) {
continue;
}
result.set(
keyMapping.get(key as string) || key,
keyMapping.get(value as string) || value,
);
}
return result;
}
}
Loading
Loading