@lionweb/class-core 0.7.0-beta.12 → 0.7.0-beta.13

package/src/deltas/index.ts

@@ -17,7 +17,9 @@
 
 export * from "./appliers.js";
 export * from "./base.js";
-export * from "./handlers.js";
+export * from "./compositor.js";
 export * from "./inverters.js";
+export * from "./receivers.js";
 export * from "./types.g.js";
 export * from "./serialization/index.js";
+

package/src/deltas/receivers.ts

@@ -0,0 +1,91 @@
+// Copyright 2025 TRUMPF Laser SE and other contributors
+//
+// Licensed under the Apache License, Version 2.0 (the "License")
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// SPDX-FileCopyrightText: 2025 TRUMPF Laser SE and other contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { IDelta } from "./base.js"
+import { serializeDelta } from "./serialization/index.js"
+
+/**
+ * A type for functions that receive deltas.
+ */
+export type DeltaReceiver = (delta: IDelta) => void;
+
+/**
+ * Legacy alias for {@link DeltaReceiver}.
+ */
+export type DeltaHandler = (delta: IDelta) => void;
+
+/**
+ * @return a tuple consisting of a {@link DeltaReceiver} implementation (as 1st member) that pushes any received delta unto the tuple's 2nd member: an array of {@link IDelta deltas}.
+ * @param printSerializations determines whether the deltas are serialized as JSON and printed to the JavaScript console.
+ */
+export const collectingDeltaReceiver = (printSerializations = false): [DeltaReceiver, IDelta[]] => {
+    const deltas: IDelta[] = [];
+    const receiveDelta: DeltaReceiver = (delta) => {
+        deltas.push(delta);
+        if (printSerializations) {
+            console.log(JSON.stringify(serializeDelta(delta), null, 4));
+        }
+    };
+    return [receiveDelta, deltas];
+};
+
+/**
+ * Legacy alias for {@link collectingDeltaReceiver}.
+ */
+export const collectingDeltaHandler = collectingDeltaReceiver;
+
+/**
+ * An interface for {@link DeltaReceiver delta receivers} that can be switched on and off — “latchingDeltaReceiverFrom”.
+ */
+export interface LatchingDeltaReceiver extends DeltaReceiver {
+    latch(emitDeltas: boolean): void;
+}
+
+/**
+ * Legacy alias for {@link LatchingDeltaReceiver}.
+ */
+export interface LatchingDeltaHandler extends LatchingDeltaReceiver {};
+
+/**
+ * @return a latching version of the given {@link DeltaReceiver delta receiver}.
+ */
+export const latchingDeltaReceiverFrom = (receiveDelta: DeltaReceiver): LatchingDeltaReceiver => {
+    let emitDeltas = false;
+    return Object.assign(
+        (delta: IDelta) => {
+            if (emitDeltas) {
+                receiveDelta(delta);
+            }
+        },
+        {
+            latch(emitDeltas_: boolean) {
+                emitDeltas = emitDeltas_;
+            },
+        },
+    );
+};
+
+
+/**
+ * @return a {@link DeltaReceiver delta receiver} implementation that forwards received deltas to the given {@link DeltaReceiver delta receivers}.
+ * This is necessary e.g. for combining using the delta protocol with an undo mechanism.
+ */
+export const deltaReceiverForwardingTo = (...deltaReceivers: DeltaReceiver[]): DeltaReceiver =>
+    (delta) => {
+        deltaReceivers.forEach((receiveDelta) => receiveDelta(delta));
+    };
+

package/src/deserializer.ts

@@ -33,7 +33,7 @@ import {
 import { LionWebId, LionWebJsonChunk, LionWebJsonNode } from "@lionweb/json"
 import { byIdMap, keepDefineds } from "@lionweb/ts-utils"
 
-import { DeltaHandler, IdMapping, ILanguageBase, INodeBase } from "./index.js"
+import { DeltaReceiver, IdMapping, ILanguageBase, INodeBase } from "./index.js"
 import { NodesToInstall } from "./linking.js"
 
 
@@ -57,9 +57,9 @@ const languageBaseLookupFor = (languageBases: ILanguageBase[]) =>
         return languageBase;
     };
 
-const factoryLookupFor = (languageBases: ILanguageBase[], handleDelta?: DeltaHandler) => {
+const factoryLookupFor = (languageBases: ILanguageBase[], receiveDelta?: DeltaReceiver) => {
     const lookup = languageBaseLookupFor(languageBases);
-    return (language: Language) => lookup(language).factory(handleDelta);
+    return (language: Language) => lookup(language).factory(receiveDelta);
 }
 
 
@@ -73,13 +73,13 @@ export type RootsWithIdMapping = { roots: INodeBase[], idMapping: IdMapping };
 /**
  * @return a {@link Deserializer} function for the given languages (given as {@link ILanguageBase}s) that returns a {@link RootsWithIdMapping}.
  * @param languageBases the {@link ILanguageBase}s for (at least) all the languages used in the {@link LionWebJsonChunk} to deserialize, minus LionCore M3 and built-ins.
- * @param handleDelta an optional {@link DeltaHandler} that will be injected in all {@link INodeBase nodes} created.
+ * @param receiveDelta an optional {@link DeltaReceiver} that will be injected in all {@link INodeBase nodes} created.
  */
-export const nodeBaseDeserializerWithIdMapping = (languageBases: ILanguageBase[], handleDelta?: DeltaHandler): Deserializer<RootsWithIdMapping> => {
+export const nodeBaseDeserializerWithIdMapping = (languageBases: ILanguageBase[], receiveDelta?: DeltaReceiver): Deserializer<RootsWithIdMapping> => {
 
     const symbolTable = new MemoisingSymbolTable(languageBases.map(({language}) => language));
     const languageBaseFor = languageBaseLookupFor(languageBases);
-    const factoryFor = factoryLookupFor(languageBases, handleDelta);
+    const factoryFor = factoryLookupFor(languageBases, receiveDelta);
 
     return (
         serializationChunk: LionWebJsonChunk,
@@ -219,10 +219,10 @@ export const nodeBaseDeserializerWithIdMapping = (languageBases: ILanguageBase[]
 /**
  * @return a {@link Deserializer} function for the languages (given as {@link ILanguageBase}s) that returns the roots (of type {@link INodeBase}) of the deserialized model.
  * @param languageBases the {@link ILanguageBase}s for (at least) all the languages used in the {@link LionWebJsonChunk} to deserialize, minus LionCore M3 and built-ins.
- * @param handleDelta an optional {@link DeltaHandler} that will be injected in all {@link INodeBase nodes} created.
+ * @param receiveDelta an optional {@link DeltaReceiver} that will be injected in all {@link INodeBase nodes} created.
  */
-export const nodeBaseDeserializer = (languageBases: ILanguageBase[], handleDelta?: DeltaHandler): Deserializer<INodeBase[]> => {
-    const deserializerWithIdMapping = nodeBaseDeserializerWithIdMapping(languageBases, handleDelta);
+export const nodeBaseDeserializer = (languageBases: ILanguageBase[], receiveDelta?: DeltaReceiver): Deserializer<INodeBase[]> => {
+    const deserializerWithIdMapping = nodeBaseDeserializerWithIdMapping(languageBases, receiveDelta);
     return (
         serializationChunk: LionWebJsonChunk,
         dependentNodes: INodeBase[] = [],

package/src/factory.ts

@@ -17,18 +17,18 @@
 
 import { lazyMapGet } from "@lionweb/ts-utils"
 import { ILanguageBase, NodeBaseFactory } from "./base-types.js"
-import { DeltaHandler } from "./deltas/index.js"
+import { DeltaReceiver } from "./deltas/index.js"
 
 /**
  * @return a {@link NodeBaseFactory factory function} that works for all given {@link ILanguageBase language bases}.
  */
-export const combinedFactoryFor = (languageBases: ILanguageBase[], handleDelta?: DeltaHandler): NodeBaseFactory => {
+export const combinedFactoryFor = (languageBases: ILanguageBase[], receiveDelta?: DeltaReceiver): NodeBaseFactory => {
     // create lookup map:
     const languageKey2version2factory: { [key: string]: { [version: string]: NodeBaseFactory } } = {}
     languageBases.forEach((languageBase) => {
         const {key, version} = languageBase.language
         const version2factory = lazyMapGet(languageKey2version2factory, key, () => ({}))
-        lazyMapGet(version2factory, version, () => languageBase.factory(handleDelta))
+        lazyMapGet(version2factory, version, () => languageBase.factory(receiveDelta))
             // (Note: don't destructure factory from languageBase, as that will unbind it as "this"!)
     })
 

package/src/value-managers/base.ts

@@ -29,12 +29,12 @@ export abstract class ValueManager {
     }
 
     /**
-     * Emits a delta if a {@link DeltaHandler} is registered with the container.
-     * @param deltaThunk a thunk that generates the delta, and is only called when a delta handler is registered with the container.
+     * Emits a delta if a {@link DeltaReceiver} is registered with the container.
+     * @param deltaThunk a thunk that generates the delta, and is only called when a delta receiver is registered with the container.
      */
     emitDelta(deltaThunk: () => IDelta) {
-        if (this.container.handleDelta) {
-            this.container.handleDelta(deltaThunk());
+        if (this.container.receiveDelta) {
+            this.container.receiveDelta(deltaThunk());
         }
     }
 

package/dist/deltas/handlers.d.ts

@@ -1,17 +0,0 @@
-import { IDelta } from "./base.js";
-/**
- * A type for functions that handle deltas.
- */
-export type DeltaHandler = (delta: IDelta) => void;
-export declare const collectingDeltaHandler: (printSerializations?: boolean) => [DeltaHandler, IDelta[]];
-/**
- * An interface for {@link DeltaHandler delta handlers} that can be switched on and off — “latching”.
- */
-export interface LatchingDeltaHandler extends DeltaHandler {
-    latch(emitDeltas: boolean): void;
-}
-/**
- * @return a latching version of the given {@link DeltaHandler delta handler}.
- */
-export declare const latching: (handleDelta: DeltaHandler) => LatchingDeltaHandler;
-//# sourceMappingURL=handlers.d.ts.map

package/dist/deltas/handlers.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"handlers.d.ts","sourceRoot":"","sources":["../../src/deltas/handlers.ts"],"names":[],"mappings":"AAiBA,OAAO,EAAE,MAAM,EAAE,MAAM,WAAW,CAAA;AAIlC;;GAEG;AACH,MAAM,MAAM,YAAY,GAAG,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;AAEnD,eAAO,MAAM,sBAAsB,GAAI,6BAA2B,KAAG,CAAC,YAAY,EAAE,MAAM,EAAE,CAS3F,CAAC;AAGF;;GAEG;AACH,MAAM,WAAW,oBAAqB,SAAQ,YAAY;IACtD,KAAK,CAAC,UAAU,EAAE,OAAO,GAAG,IAAI,CAAC;CACpC;AAED;;GAEG;AACH,eAAO,MAAM,QAAQ,GAAI,aAAa,YAAY,KAAG,oBAcpD,CAAC"}

package/dist/deltas/handlers.js

@@ -1,43 +0,0 @@
-// Copyright 2025 TRUMPF Laser SE and other contributors
-//
-// Licensed under the Apache License, Version 2.0 (the "License")
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-// SPDX-FileCopyrightText: 2025 TRUMPF Laser SE and other contributors
-// SPDX-License-Identifier: Apache-2.0
-import { serializeDelta } from "./serialization/index.js";
-export const collectingDeltaHandler = (printSerializations = false) => {
-    const deltas = [];
-    const handleDelta = (delta) => {
-        deltas.push(delta);
-        if (printSerializations) {
-            console.log(JSON.stringify(serializeDelta(delta), null, 4));
-        }
-    };
-    return [handleDelta, deltas];
-};
-/**
- * @return a latching version of the given {@link DeltaHandler delta handler}.
- */
-export const latching = (handleDelta) => {
-    let emitDeltas = false;
-    return Object.assign((delta) => {
-        if (emitDeltas) {
-            handleDelta(delta);
-        }
-    }, {
-        latch(emitDeltas_) {
-            emitDeltas = emitDeltas_;
-        },
-    });
-};
-//# sourceMappingURL=handlers.js.map

package/dist/deltas/handlers.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"handlers.js","sourceRoot":"","sources":["../../src/deltas/handlers.ts"],"names":[],"mappings":"AAAA,wDAAwD;AACxD,EAAE;AACF,iEAAiE;AACjE,mEAAmE;AACnE,0CAA0C;AAC1C,EAAE;AACF,iDAAiD;AACjD,EAAE;AACF,sEAAsE;AACtE,oEAAoE;AACpE,2EAA2E;AAC3E,sEAAsE;AACtE,iCAAiC;AACjC,EAAE;AACF,sEAAsE;AACtE,sCAAsC;AAGtC,OAAO,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAA;AAQzD,MAAM,CAAC,MAAM,sBAAsB,GAAG,CAAC,mBAAmB,GAAG,KAAK,EAA4B,EAAE;IAC5F,MAAM,MAAM,GAAa,EAAE,CAAC;IAC5B,MAAM,WAAW,GAAiB,CAAC,KAAK,EAAE,EAAE;QACxC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QACnB,IAAI,mBAAmB,EAAE,CAAC;YACtB,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,SAAS,CAAC,cAAc,CAAC,KAAK,CAAC,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC,CAAC;QAChE,CAAC;IACL,CAAC,CAAC;IACF,OAAO,CAAC,WAAW,EAAE,MAAM,CAAC,CAAC;AACjC,CAAC,CAAC;AAUF;;GAEG;AACH,MAAM,CAAC,MAAM,QAAQ,GAAG,CAAC,WAAyB,EAAwB,EAAE;IACxE,IAAI,UAAU,GAAG,KAAK,CAAC;IACvB,OAAO,MAAM,CAAC,MAAM,CAChB,CAAC,KAAa,EAAE,EAAE;QACd,IAAI,UAAU,EAAE,CAAC;YACb,WAAW,CAAC,KAAK,CAAC,CAAC;QACvB,CAAC;IACL,CAAC,EACD;QACI,KAAK,CAAC,WAAoB;YACtB,UAAU,GAAG,WAAW,CAAC;QAC7B,CAAC;KACJ,CACJ,CAAC;AACN,CAAC,CAAC"}

package/src/deltas/handlers.ts

@@ -1,64 +0,0 @@
-// Copyright 2025 TRUMPF Laser SE and other contributors
-//
-// Licensed under the Apache License, Version 2.0 (the "License")
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-// SPDX-FileCopyrightText: 2025 TRUMPF Laser SE and other contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import { IDelta } from "./base.js"
-import { serializeDelta } from "./serialization/index.js"
-
-
-/**
- * A type for functions that handle deltas.
- */
-export type DeltaHandler = (delta: IDelta) => void;
-
-export const collectingDeltaHandler = (printSerializations = false): [DeltaHandler, IDelta[]] => {
-    const deltas: IDelta[] = [];
-    const handleDelta: DeltaHandler = (delta) => {
-        deltas.push(delta);
-        if (printSerializations) {
-            console.log(JSON.stringify(serializeDelta(delta), null, 4));
-        }
-    };
-    return [handleDelta, deltas];
-};
-
-
-/**
- * An interface for {@link DeltaHandler delta handlers} that can be switched on and off — “latching”.
- */
-export interface LatchingDeltaHandler extends DeltaHandler {
-    latch(emitDeltas: boolean): void;
-}
-
-/**
- * @return a latching version of the given {@link DeltaHandler delta handler}.
- */
-export const latching = (handleDelta: DeltaHandler): LatchingDeltaHandler => {
-    let emitDeltas = false;
-    return Object.assign(
-        (delta: IDelta) => {
-            if (emitDeltas) {
-                handleDelta(delta);
-            }
-        },
-        {
-            latch(emitDeltas_: boolean) {
-                emitDeltas = emitDeltas_;
-            },
-        },
-    );
-};
-