@milaboratories/pl-tree 1.8.33 → 1.8.35

package/src/snapshot.test.ts

@@ -1,9 +1,9 @@
-import { expect, test } from 'vitest';
-import { Computable } from '@milaboratories/computable';
-import { DefaultFinalResourceDataPredicate, ResourceId } from '@milaboratories/pl-client';
-import { z } from 'zod';
-import { InferSnapshot, makeResourceSnapshot, rsSchema } from './snapshot';
-import { PlTreeState } from './state';
+import { expect, test } from "vitest";
+import { Computable } from "@milaboratories/computable";
+import { DefaultFinalResourceDataPredicate, ResourceId } from "@milaboratories/pl-client";
+import { z } from "zod";
+import { InferSnapshot, makeResourceSnapshot, rsSchema } from "./snapshot";
+import { PlTreeState } from "./state";
 import {
   TestDynamicRootId1,
   TestDynamicRootState1,
@@ -11,26 +11,26 @@ import {
   TestStructuralResourceType1,
   TestValueResourceState1,
   dField,
-  iField
-} from './test_utils';
+  iField,
+} from "./test_utils";
 
 // schema definition
 const MyTestResourceState = rsSchema({
   data: z.object({
-    jf: z.number()
+    jf: z.number(),
   }),
   fields: { b: true, c: false },
-  kv: { thekey: z.string() }
+  kv: { thekey: z.string() },
 });
 
 // type derived from schema for out users and us
 type MyTestResourceState = InferSnapshot<typeof MyTestResourceState>;
 
-test('simple snapshot test', async () => {
+test("simple snapshot test", async () => {
   const tree = new PlTreeState(TestDynamicRootId1, DefaultFinalResourceDataPredicate);
 
   const c1 = Computable.make((ctx) => {
-    const accessor = ctx.accessor(tree.entry()).node().traverse('a');
+    const accessor = ctx.accessor(tree.entry()).node().traverse("a");
     if (accessor == undefined) return undefined;
 
     const result: MyTestResourceState = makeResourceSnapshot(accessor, MyTestResourceState);
@@ -38,31 +38,31 @@ test('simple snapshot test', async () => {
   });
 
   tree.updateFromResourceData([
-    { ...TestDynamicRootState1, fields: [dField('b'), dField('a', rid(1n))] },
+    { ...TestDynamicRootState1, fields: [dField("b"), dField("a", rid(1n))] },
     {
       ...TestStructuralResourceState1,
       id: rid(1n),
-      fields: [iField('b', rid(2n))],
-      data: new TextEncoder().encode(`{"jf": 0}`)
+      fields: [iField("b", rid(2n))],
+      data: new TextEncoder().encode(`{"jf": 0}`),
     },
     {
       ...TestValueResourceState1,
-      id: rid(2n)
-    }
+      id: rid(2n),
+    },
   ]);
 
   expect(c1.isChanged()).toBeTruthy();
-  expect((await c1.getValueOrError()).type).toStrictEqual('error');
+  expect((await c1.getValueOrError()).type).toStrictEqual("error");
   expect(c1.isChanged()).toBeFalsy();
 
   tree.updateFromResourceData([
     {
       ...TestValueResourceState1,
       id: rid(1n),
-      fields: [iField('b', rid(2n))],
+      fields: [iField("b", rid(2n))],
       data: new TextEncoder().encode(`{"jf": 0}`),
-      kv: [{ key: 'thekey', value: Buffer.from('"thevalue"') }]
-    }
+      kv: [{ key: "thekey", value: Buffer.from('"thevalue"') }],
+    },
   ]);
 
   expect(c1.isChanged()).toBeTruthy();
@@ -70,15 +70,15 @@ test('simple snapshot test', async () => {
     id: rid(1n),
     type: TestStructuralResourceType1,
     data: {
-      jf: 0
+      jf: 0,
     },
     fields: {
       b: rid(2n),
-      c: undefined
+      c: undefined,
     },
     kv: {
-      thekey: 'thevalue'
-    }
+      thekey: "thevalue",
+    },
   } as MyTestResourceState);
   expect(c1.isChanged()).toBeFalsy();
 
@@ -86,14 +86,14 @@ test('simple snapshot test', async () => {
     {
       ...TestValueResourceState1,
       id: rid(1n),
-      fields: [iField('b', rid(2n))],
+      fields: [iField("b", rid(2n))],
       data: new TextEncoder().encode(`{"jf": 0}`),
-      kv: [{ key: 'thekey', value: Buffer.from('123') }] // thekey type changed to number (invalid accordig to zod schema)
-    }
+      kv: [{ key: "thekey", value: Buffer.from("123") }], // thekey type changed to number (invalid accordig to zod schema)
+    },
   ]);
 
   expect(c1.isChanged()).toBeTruthy();
-  expect((await c1.getValueOrError()).type).toStrictEqual('error');
+  expect((await c1.getValueOrError()).type).toStrictEqual("error");
   expect(c1.isChanged()).toBeFalsy();
 });
 

package/src/snapshot.ts

@@ -1,10 +1,10 @@
-import type { ResourceId, ResourceType } from '@milaboratories/pl-client';
-import type { Optional, Writable } from 'utility-types';
-import type { ZodType, z } from 'zod';
-import type { PlTreeNodeAccessor } from './accessors';
-import { PlTreeEntry, PlTreeEntryAccessor } from './accessors';
-import type { ComputableCtx } from '@milaboratories/computable';
-import { notEmpty } from '@milaboratories/ts-helpers';
+import type { ResourceId, ResourceType } from "@milaboratories/pl-client";
+import type { Optional, Writable } from "utility-types";
+import type { ZodType, z } from "zod";
+import type { PlTreeNodeAccessor } from "./accessors";
+import { PlTreeEntry, PlTreeEntryAccessor } from "./accessors";
+import type { ComputableCtx } from "@milaboratories/computable";
+import { notEmpty } from "@milaboratories/ts-helpers";
 
 /**
  * A DTO that can be generated from a tree node to make a snapshot of specific parts of it's state.
@@ -32,9 +32,9 @@ type ResourceSnapshotGeneric = ResourceSnapshot<
 
 /** Request that we'll pass to getResourceSnapshot function. We infer the type of ResourceSnapshot from this. */
 export type ResourceSnapshotSchema<
-  Data extends ZodType | 'raw' | undefined = undefined,
+  Data extends ZodType | "raw" | undefined = undefined,
   Fields extends Record<string, boolean> | undefined = undefined,
-  KV extends Record<string, ZodType | 'raw'> | undefined = undefined,
+  KV extends Record<string, ZodType | "raw"> | undefined = undefined,
 > = {
   readonly data: Data;
   readonly fields: Fields;
@@ -43,9 +43,9 @@ export type ResourceSnapshotSchema<
 
 /** Creates ResourceSnapshotSchema. It converts an optional schema type to schema type. */
 export function rsSchema<
-  const Data extends ZodType | 'raw' | undefined = undefined,
+  const Data extends ZodType | "raw" | undefined = undefined,
   const Fields extends Record<string, boolean> | undefined = undefined,
-  const KV extends Record<string, ZodType | 'raw'> | undefined = undefined,
+  const KV extends Record<string, ZodType | "raw"> | undefined = undefined,
 >(
   schema: Optional<ResourceSnapshotSchema<Data, Fields, KV>>,
 ): ResourceSnapshotSchema<Data, Fields, KV> {
@@ -54,9 +54,9 @@ export function rsSchema<
 
 /** The most generic type of ResourceSnapshotSchema. */
 type ResourceSnapshotSchemaGeneric = ResourceSnapshotSchema<
-  ZodType | 'raw' | undefined,
+  ZodType | "raw" | undefined,
   Record<string, boolean> | undefined,
-  Record<string, ZodType | 'raw'> | undefined
+  Record<string, ZodType | "raw"> | undefined
 >;
 
 /**
@@ -64,7 +64,7 @@ type ResourceSnapshotSchemaGeneric = ResourceSnapshotSchema<
  * if it's Zod, we'll parse it via zod.
  * Or else we just got undefined in the field.
  */
-type InferDataType<Data extends ZodType | 'raw' | undefined> = Data extends 'raw'
+type InferDataType<Data extends ZodType | "raw" | undefined> = Data extends "raw"
   ? Uint8Array
   : Data extends ZodType
     ? z.infer<Data>
@@ -89,7 +89,7 @@ type InferFieldsType<Fields extends Record<string, boolean> | undefined> = Field
  * If one of values is Zod, we'll get KV and converts it to Zod schema.
  * If the value is 'raw', just returns bytes.
  */
-type InferKVType<KV extends Record<string, ZodType | 'raw'> | undefined> = KV extends undefined
+type InferKVType<KV extends Record<string, ZodType | "raw"> | undefined> = KV extends undefined
   ? undefined
   : {
       [FieldName in keyof KV]: KV[FieldName] extends ZodType ? z.infer<KV[FieldName]> : Uint8Array;
@@ -97,37 +97,37 @@ type InferKVType<KV extends Record<string, ZodType | 'raw'> | undefined> = KV ex
 
 /** Infer ResourceSnapshot from ResourceShapshotSchema, S can be any ResourceSnapshotSchema. */
 export type InferSnapshot<S extends ResourceSnapshotSchemaGeneric> = ResourceSnapshot<
-  InferDataType<S['data']>,
-  InferFieldsType<S['fields']>,
-  InferKVType<S['kv']>
+  InferDataType<S["data"]>,
+  InferFieldsType<S["fields"]>,
+  InferKVType<S["kv"]>
 >;
 
 /** Gets a ResourceSnapshot from PlTreeEntry. */
 export function makeResourceSnapshot<Schema extends ResourceSnapshotSchemaGeneric>(
   res: PlTreeEntry,
   schema: Schema,
-  ctx: ComputableCtx
+  ctx: ComputableCtx,
 ): InferSnapshot<Schema>;
 export function makeResourceSnapshot<Schema extends ResourceSnapshotSchemaGeneric>(
   res: PlTreeEntryAccessor | PlTreeNodeAccessor,
-  schema: Schema
+  schema: Schema,
 ): InferSnapshot<Schema>;
 export function makeResourceSnapshot<Schema extends ResourceSnapshotSchemaGeneric>(
   res: PlTreeEntry | PlTreeEntryAccessor | PlTreeNodeAccessor,
   schema: Schema,
   ctx?: ComputableCtx,
 ): InferSnapshot<Schema> {
-  const node
-    = res instanceof PlTreeEntry
+  const node =
+    res instanceof PlTreeEntry
       ? notEmpty(ctx).accessor(res).node()
       : res instanceof PlTreeEntryAccessor
         ? res.node()
         : res;
   const info = node.resourceInfo;
-  const result: Optional<Writable<ResourceSnapshotGeneric>, 'data' | 'fields' | 'kv'> = { ...info };
+  const result: Optional<Writable<ResourceSnapshotGeneric>, "data" | "fields" | "kv"> = { ...info };
 
   if (schema.data !== undefined) {
-    if (schema.data === 'raw') result.data = node.getData();
+    if (schema.data === "raw") result.data = node.getData();
     else result.data = schema.data.parse(node.getDataAsJson());
   }
 
@@ -151,10 +151,10 @@ export function makeResourceSnapshot<Schema extends ResourceSnapshotSchemaGeneri
 
       if (value === undefined) {
         throw new Error(`Key not found ${fieldName}`);
-      } else if (type === 'raw') {
+      } else if (type === "raw") {
         kv[fieldName] = value;
       } else {
-        kv[fieldName] = type.parse(JSON.parse(Buffer.from(value).toString('utf-8')));
+        kv[fieldName] = type.parse(JSON.parse(Buffer.from(value).toString("utf-8")));
       }
     }
     result.kv = kv;

package/src/state.test.ts

@@ -1,8 +1,12 @@
-import { expect, test } from 'vitest';
-import { Computable } from '@milaboratories/computable';
-import { DefaultFinalResourceDataPredicate, NullResourceId, ResourceId } from '@milaboratories/pl-client';
-import { isPlTreeEntry, isPlTreeEntryAccessor, isPlTreeNodeAccessor } from './accessors';
-import { PlTreeState } from './state';
+import { expect, test } from "vitest";
+import { Computable } from "@milaboratories/computable";
+import {
+  DefaultFinalResourceDataPredicate,
+  NullResourceId,
+  ResourceId,
+} from "@milaboratories/pl-client";
+import { isPlTreeEntry, isPlTreeEntryAccessor, isPlTreeNodeAccessor } from "./accessors";
+import { PlTreeState } from "./state";
 import {
   dField,
   iField,
@@ -11,15 +15,14 @@ import {
   TestDynamicRootState1,
   TestErrorResourceState2,
   TestStructuralResourceState1,
-  TestValueResourceState1
-} from './test_utils';
-
+  TestValueResourceState1,
+} from "./test_utils";
 
 function rid(id: bigint): ResourceId {
   return id as ResourceId;
 }
 
-test('simple tree test 1', async () => {
+test("simple tree test 1", async () => {
   const tree = new PlTreeState(TestDynamicRootId1, DefaultFinalResourceDataPredicate);
   const entry = tree.entry();
   expect(isPlTreeEntry(entry)).toStrictEqual(true);
@@ -28,7 +31,7 @@ test('simple tree test 1', async () => {
     expect(isPlTreeEntryAccessor(eAcc)).toStrictEqual(true);
     const nAcc = eAcc.node();
     expect(isPlTreeNodeAccessor(nAcc)).toStrictEqual(true);
-    return nAcc.traverse('a', 'b')?.getDataAsString();
+    return nAcc.traverse("a", "b")?.getDataAsString();
   });
 
   expect(c1.isChanged()).toBeTruthy();
@@ -40,39 +43,39 @@ test('simple tree test 1', async () => {
   expect(await c1.getValue()).toBeUndefined();
   expect(c1.isChanged()).toBeFalsy();
 
-  tree.updateFromResourceData([{ ...TestDynamicRootState1, fields: [dField('b')] }]);
+  tree.updateFromResourceData([{ ...TestDynamicRootState1, fields: [dField("b")] }]);
   expect(c1.isChanged()).toBeTruthy();
   expect(await c1.getValue()).toBeUndefined();
   expect(c1.isChanged()).toBeFalsy();
 
-  tree.updateFromResourceData([{ ...TestDynamicRootState1, fields: [dField('b'), dField('a')] }]);
+  tree.updateFromResourceData([{ ...TestDynamicRootState1, fields: [dField("b"), dField("a")] }]);
   expect(c1.isChanged()).toBeTruthy();
   expect(await c1.getValue()).toBeUndefined();
   expect(c1.isChanged()).toBeFalsy();
 
   tree.updateFromResourceData([
-    { ...TestDynamicRootState1, fields: [dField('b'), dField('a', rid(rid(1n)))] },
-    { ...TestStructuralResourceState1, id: rid(rid(1n)), fields: [iField('b', rid(rid(2n)))] },
+    { ...TestDynamicRootState1, fields: [dField("b"), dField("a", rid(rid(1n)))] },
+    { ...TestStructuralResourceState1, id: rid(rid(1n)), fields: [iField("b", rid(rid(2n)))] },
     {
       ...TestValueResourceState1,
       id: rid(rid(2n)),
-      data: new TextEncoder().encode('Test1')
-    }
+      data: new TextEncoder().encode("Test1"),
+    },
   ]);
   expect(c1.isChanged()).toBeTruthy();
-  expect(await c1.getValue()).toStrictEqual('Test1');
+  expect(await c1.getValue()).toStrictEqual("Test1");
   expect(c1.isChanged()).toBeFalsy();
 
-  tree.updateFromResourceData([{ ...TestDynamicRootState1, fields: [dField('a')] }]);
+  tree.updateFromResourceData([{ ...TestDynamicRootState1, fields: [dField("a")] }]);
   expect(c1.isChanged()).toBeTruthy();
   expect(await c1.getValue()).toBeUndefined();
   expect(c1.isChanged()).toBeFalsy();
 });
 
-test('simple tree kv test', async () => {
+test("simple tree kv test", async () => {
   const tree = new PlTreeState(TestDynamicRootId1, DefaultFinalResourceDataPredicate);
   const c1 = Computable.make((c) =>
-    c.accessor(tree.entry()).node().traverse('a', 'b')?.getKeyValueAsString('thekey')
+    c.accessor(tree.entry()).node().traverse("a", "b")?.getKeyValueAsString("thekey"),
   );
 
   expect(JSON.stringify(tree.entry())).toMatch(/^"\[ENTRY:/);
@@ -82,13 +85,13 @@ test('simple tree kv test', async () => {
   expect(c1.isChanged()).toBeFalsy();
 
   tree.updateFromResourceData([
-    { ...TestDynamicRootState1, fields: [dField('b'), dField('a', rid(rid(1n)))] },
-    { ...TestStructuralResourceState1, id: rid(rid(1n)), fields: [iField('b', rid(rid(2n)))] },
+    { ...TestDynamicRootState1, fields: [dField("b"), dField("a", rid(rid(1n)))] },
+    { ...TestStructuralResourceState1, id: rid(rid(1n)), fields: [iField("b", rid(rid(2n)))] },
     {
       ...TestValueResourceState1,
       id: rid(rid(2n)),
-      data: new TextEncoder().encode('Test1')
-    }
+      data: new TextEncoder().encode("Test1"),
+    },
   ]);
 
   expect(c1.isChanged()).toBeTruthy();
@@ -99,22 +102,22 @@ test('simple tree kv test', async () => {
     {
       ...TestValueResourceState1,
       id: rid(rid(2n)),
-      data: new TextEncoder().encode('Test1'),
-      kv: [{ key: 'thekey', value: Buffer.from('thevalue') }]
-    }
+      data: new TextEncoder().encode("Test1"),
+      kv: [{ key: "thekey", value: Buffer.from("thevalue") }],
+    },
   ]);
 
   expect(c1.isChanged()).toBeTruthy();
-  expect(await c1.getValue()).toEqual('thevalue');
+  expect(await c1.getValue()).toEqual("thevalue");
   expect(c1.isChanged()).toBeFalsy();
 
   tree.updateFromResourceData([
     {
       ...TestValueResourceState1,
       id: rid(rid(2n)),
-      data: new TextEncoder().encode('Test1'),
-      kv: []
-    }
+      data: new TextEncoder().encode("Test1"),
+      kv: [],
+    },
   ]);
 
   expect(c1.isChanged()).toBeTruthy();
@@ -122,17 +125,17 @@ test('simple tree kv test', async () => {
   expect(c1.isChanged()).toBeFalsy();
 });
 
-test('partial tree update', async () => {
+test("partial tree update", async () => {
   const tree = new PlTreeState(TestDynamicRootId1, DefaultFinalResourceDataPredicate);
   const c1 = Computable.make((c) =>
     c
       .accessor(tree.entry())
       .node()
       .traverse(
-        { field: 'a', assertFieldType: 'Dynamic' },
-        { field: 'b', assertFieldType: 'Dynamic' }
+        { field: "a", assertFieldType: "Dynamic" },
+        { field: "b", assertFieldType: "Dynamic" },
       )
-      ?.getDataAsString()
+      ?.getDataAsString(),
   );
 
   expect(c1.isChanged()).toBeTruthy();
@@ -140,16 +143,16 @@ test('partial tree update', async () => {
   expect(c1.isChanged()).toBeFalsy();
 
   tree.updateFromResourceData([
-    { ...TestDynamicRootState1, fields: [dField('b'), dField('a', rid(1n))] },
-    { ...TestStructuralResourceState1, id: rid(1n), fields: [dField('b', rid(2n))] },
+    { ...TestDynamicRootState1, fields: [dField("b"), dField("a", rid(1n))] },
+    { ...TestStructuralResourceState1, id: rid(1n), fields: [dField("b", rid(2n))] },
     {
       ...TestValueResourceState1,
       id: rid(2n),
-      data: new TextEncoder().encode('Test1')
-    }
+      data: new TextEncoder().encode("Test1"),
+    },
   ]);
   expect(c1.isChanged()).toBeTruthy();
-  expect(await c1.getValue()).toStrictEqual('Test1');
+  expect(await c1.getValue()).toStrictEqual("Test1");
   expect(c1.isChanged()).toBeFalsy();
 
   tree.updateFromResourceData([{ ...TestStructuralResourceState1, id: rid(1n), fields: [] }]);
@@ -158,10 +161,10 @@ test('partial tree update', async () => {
   expect(c1.isChanged()).toBeFalsy();
 });
 
-test('resource error', async () => {
+test("resource error", async () => {
   const tree = new PlTreeState(TestDynamicRootId1, DefaultFinalResourceDataPredicate);
   const c1 = Computable.make((c) =>
-    c.accessor(tree.entry()).node().traverse('a', 'b')?.getKeyValueAsString('thekey')
+    c.accessor(tree.entry()).node().traverse("a", "b")?.getKeyValueAsString("thekey"),
   );
 
   expect(c1.isChanged()).toBeTruthy();
@@ -174,17 +177,17 @@ test('resource error', async () => {
       ...TestErrorResourceState2,
       id: rid(7n),
       data: Buffer.from('"error"'),
-      fields: []
-    }
+      fields: [],
+    },
   ]);
 
-  expect((await c1.getValueOrError()).type).toEqual('error');
+  expect((await c1.getValueOrError()).type).toEqual("error");
 });
 
-test('field error', async () => {
+test("field error", async () => {
   const tree = new PlTreeState(TestDynamicRootId1, DefaultFinalResourceDataPredicate);
   const c1 = Computable.make((c) =>
-    c.accessor(tree.entry()).node().traverse('b', 'a')?.getKeyValueAsString('thekey')
+    c.accessor(tree.entry()).node().traverse("b", "a")?.getKeyValueAsString("thekey"),
   );
 
   expect(c1.isChanged()).toBeTruthy();
@@ -194,53 +197,53 @@ test('field error', async () => {
   tree.updateFromResourceData([
     {
       ...TestDynamicRootState1,
-      fields: [dField('b', NullResourceId, rid(7n))]
+      fields: [dField("b", NullResourceId, rid(7n))],
     },
     {
       ...TestErrorResourceState2,
       id: rid(7n),
       data: Buffer.from('"error"'),
-      fields: []
-    }
+      fields: [],
+    },
   ]);
 
-  expect((await c1.getValueOrError()).type).toEqual('error');
+  expect((await c1.getValueOrError()).type).toEqual("error");
 });
 
-test('exception - deletion of input field', () => {
+test("exception - deletion of input field", () => {
   const tree = new PlTreeState(TestDynamicRootId1, DefaultFinalResourceDataPredicate);
 
   tree.updateFromResourceData([
-    { ...TestDynamicRootState1, fields: [dField('b'), dField('a', rid(1n))] },
-    { ...TestStructuralResourceState1, id: rid(1n), fields: [iField('b', rid(2n))] },
+    { ...TestDynamicRootState1, fields: [dField("b"), dField("a", rid(1n))] },
+    { ...TestStructuralResourceState1, id: rid(1n), fields: [iField("b", rid(2n))] },
     {
       ...TestValueResourceState1,
       id: rid(2n),
-      data: new TextEncoder().encode('Test1')
-    }
+      data: new TextEncoder().encode("Test1"),
+    },
   ]);
 
   expect(() =>
-    tree.updateFromResourceData([{ ...TestStructuralResourceState1, id: rid(1n), fields: [] }])
+    tree.updateFromResourceData([{ ...TestStructuralResourceState1, id: rid(1n), fields: [] }]),
   ).toThrow(/removal of Input field/);
 });
 
-test('exception - addition of input field', () => {
+test("exception - addition of input field", () => {
   const tree = new PlTreeState(TestDynamicRootId1, DefaultFinalResourceDataPredicate);
 
   tree.updateFromResourceData([
-    { ...TestDynamicRootState1, fields: [dField('b'), dField('a', rid(1n))] },
+    { ...TestDynamicRootState1, fields: [dField("b"), dField("a", rid(1n))] },
     {
       ...TestStructuralResourceState1,
       id: rid(1n),
-      fields: [iField('b', rid(2n))],
-      ...ResourceReady
+      fields: [iField("b", rid(2n))],
+      ...ResourceReady,
     },
     {
       ...TestValueResourceState1,
       id: rid(2n),
-      data: new TextEncoder().encode('Test1')
-    }
+      data: new TextEncoder().encode("Test1"),
+    },
   ]);
 
   expect(() =>
@@ -248,71 +251,71 @@ test('exception - addition of input field', () => {
       {
         ...TestStructuralResourceState1,
         id: rid(1n),
-        fields: [iField('b', rid(2n)), iField('df')],
-        ...ResourceReady
-      }
-    ])
+        fields: [iField("b", rid(2n)), iField("df")],
+        ...ResourceReady,
+      },
+    ]),
   ).toThrow(/adding Input/);
 });
 
-test('exception - ready without locks 1', () => {
+test("exception - ready without locks 1", () => {
   const tree = new PlTreeState(TestDynamicRootId1, DefaultFinalResourceDataPredicate);
 
   expect(() =>
     tree.updateFromResourceData([
       {
         ...TestDynamicRootState1,
-        fields: [dField('b'), dField('a', rid(1n))]
+        fields: [dField("b"), dField("a", rid(1n))],
       },
       {
         ...TestStructuralResourceState1,
         id: rid(1n),
-        fields: [iField('b', rid(2n))],
-        resourceReady: true
+        fields: [iField("b", rid(2n))],
+        resourceReady: true,
       },
       {
         ...TestValueResourceState1,
         id: rid(2n),
-        data: new TextEncoder().encode('Test1')
-      }
-    ])
+        data: new TextEncoder().encode("Test1"),
+      },
+    ]),
   ).toThrow(/ready without input or output lock/);
 });
 
-test('exception - ready without locks 2', () => {
+test("exception - ready without locks 2", () => {
   const tree = new PlTreeState(TestDynamicRootId1, DefaultFinalResourceDataPredicate);
 
   tree.updateFromResourceData([
-    { ...TestDynamicRootState1, fields: [dField('b'), dField('a', rid(1n))] },
+    { ...TestDynamicRootState1, fields: [dField("b"), dField("a", rid(1n))] },
     {
       ...TestStructuralResourceState1,
       id: rid(1n),
-      fields: [iField('b', rid(2n))]
+      fields: [iField("b", rid(2n))],
     },
     {
       ...TestValueResourceState1,
       id: rid(2n),
-      data: new TextEncoder().encode('Test1')
-    }
+      data: new TextEncoder().encode("Test1"),
+    },
   ]);
 
   expect(() =>
     tree.updateFromResourceData([
       {
         ...TestDynamicRootState1,
-        fields: [dField('b'), dField('a', rid(1n))]
+        fields: [dField("b"), dField("a", rid(1n))],
       },
       {
         ...TestStructuralResourceState1,
         id: rid(1n),
-        fields: [iField('b', rid(2n))],
-        resourceReady: true
+        fields: [iField("b", rid(2n))],
+        resourceReady: true,
       },
       {
         ...TestValueResourceState1,
         id: rid(2n),
-        data: new TextEncoder().encode('Test1')
-      }
-    ])
+        data: new TextEncoder().encode("Test1"),
+      },
+    ]),
   ).toThrow(/ready without input or output lock/);
 });