Skip to content

Visualize Your Ideas With Code

feat(core): preserve custom fields in meta files (#534)

Jacob2e3e22efd62b
diff --git a/packages/core/src/meta/ObjectMetaField.ts b/packages/core/src/meta/ObjectMetaField.ts
index f4f1571e..ba7dbd27 100644
--- a/packages/core/src/meta/ObjectMetaField.ts
+++ b/packages/core/src/meta/ObjectMetaField.ts
@@ -4,6 +4,19 @@ type ValueOf<T extends Record<string, any>> = {
[K in keyof T]: T[K] extends MetaField<any, infer P> ? P : never;
};
+type TransformationOf<
+ TObject extends Record<string, any>,
+ TKey extends CallableKeys<MetaField<any>>,
+> = {
+ [K in keyof TObject]: TObject[K] extends MetaField<infer A, infer B>
+ ? ReturnType<MetaField<A, B>[TKey]>
+ : never;
+};
+
+type CallableKeys<T> = {
+ [K in keyof T]: T[K] extends () => void ? K : never;
+}[keyof T];
+
/**
* Represents an object with nested meta-fields.
*/
@@ -11,17 +24,20 @@ class ObjectMetaFieldInternal<
T extends Record<string, MetaField<any>>,
> extends MetaField<ValueOf<T>> {
protected ignoreChange = false;
+ protected customFields: Record<string, unknown> = {};
+ protected readonly fields: Map<string, MetaField<unknown>>;
- public constructor(name: string, protected readonly fields: T) {
- const entries = Object.entries(fields);
+ public constructor(name: string, fields: T) {
+ const map = new Map(Object.entries(fields));
super(
name,
Object.fromEntries(
- entries.map(([name, field]) => [name, field.get()]),
+ Array.from(map, ([name, field]) => [name, field.get()]),
) as ValueOf<T>,
);
- for (const [key, field] of entries) {
+ this.fields = map;
+ for (const [key, field] of this.fields) {
Object.defineProperty(this, key, {value: field});
field.onChanged.subscribe(this.handleChange);
}
@@ -30,39 +46,41 @@ class ObjectMetaFieldInternal<
public override set(value: ValueOf<T>) {
this.ignoreChange = true;
for (const [key, fieldValue] of Object.entries(value)) {
- this.fields[key]?.set(fieldValue);
+ const field = this.fields.get(key);
+ if (field) {
+ field.set(fieldValue);
+ } else {
+ this.customFields[key] = fieldValue;
+ }
}
this.ignoreChange = false;
this.handleChange();
}
public override serialize(): ValueOf<T> {
- return Object.fromEntries(
- Object.entries(this.fields).map(([name, field]) => [
- name,
- field.serialize(),
- ]),
- ) as ValueOf<T>;
+ return this.transform('serialize');
+ }
+
+ public override clone(): this {
+ return new (<any>this.constructor)(this.name, this.transform('clone'));
}
protected handleChange = () => {
if (this.ignoreChange) return;
-
- this.value.current = Object.fromEntries(
- Object.entries(this.fields).map(([name, field]) => [name, field.get()]),
- ) as ValueOf<T>;
+ this.value.current = this.transform('get');
};
- public override clone(): this {
- return new (<any>this.constructor)(
- this.name,
- Object.fromEntries(
- Object.entries(this.fields).map(([name, field]) => [
- name,
- field.clone(),
- ]),
- ),
- );
+ protected transform<TKey extends CallableKeys<MetaField<any>>>(
+ fn: TKey,
+ ): TransformationOf<T, TKey> {
+ const transformed = Object.fromEntries(
+ Array.from(this.fields, ([name, field]) => [name, field[fn]()]),
+ ) as TransformationOf<T, TKey>;
+
+ return {
+ ...transformed,
+ ...this.customFields,
+ };
}
}