refactor(vue-model-api): fix typos

Author: Oleksandr Dzhychko

vue-model-api/src/internal/ReactiveINodeJS.ts

@@ -11,12 +11,12 @@ export function toReactiveINodeJS(
   return cache.memoize(node, () => new ReactiveINodeJS(node, cache));
 }
 
-// This declaration specifies the types of the implemenation in `unwrapReactiveINodeJS` further.
+// This declaration specifies the types of the implementation in `unwrapReactiveINodeJS` further.
 // It declares, that when
 // * an `INodeJS` is given an `INodeJS` is returned
 // * an `undefined` is given an `undefined` is returned
 // * an `null` is given an `null` is returned
-// This so called conditional types help avoid unneed assertsion about types on the usage site.
+// This so called conditional types help avoid unneeded assertions about types on the usage site.
 // See. https://www.typescriptlang.org/docs/handbook/2/conditional-types.html
 function unwrapReactiveINodeJS<T extends INodeJS | null | undefined>(
   maybeReactive: T,
@@ -34,7 +34,7 @@ function unwrapReactiveINodeJS(
   }
 }
 
-// `any` is currectly provided as the type for references from `@modelix/ts-model-api`,
+// `any` is correctly provided as the type for references from `@modelix/ts-model-api`,
 // so we have to work with it for now.
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 type INodeReferenceJS = any;
@@ -108,10 +108,10 @@ export class ReactiveINodeJS implements INodeJS {
 
   getParent(): INodeJS | undefined {
     // This does not need to be made reacitve for the same reason as getRoleInParent
-    const unreacitveNode = this.unreactiveNode.getParent();
-    return unreacitveNode
-      ? toReactiveINodeJS(unreacitveNode, this.cache)
-      : unreacitveNode;
+    const unreactiveNode = this.unreactiveNode.getParent();
+    return unreactiveNode
+      ? toReactiveINodeJS(unreactiveNode, this.cache)
+      : unreactiveNode;
   }
 
   remove(): void {
@@ -143,12 +143,12 @@ export class ReactiveINodeJS implements INodeJS {
     index: number,
     concept: IConceptJS | undefined,
   ): INodeJS {
-    const unreacitveNode = this.unreactiveNode.addNewChild(
+    const unreactiveNode = this.unreactiveNode.addNewChild(
       role,
       index,
       concept,
     );
-    return toReactiveINodeJS(unreacitveNode, this.cache);
+    return toReactiveINodeJS(unreactiveNode, this.cache);
   }
 
   removeChild(child: INodeJS): void {
@@ -200,7 +200,11 @@ export class ReactiveINodeJS implements INodeJS {
   }
 
   getPropertyValue(role: string): string | undefined {
-    const ref = this.getOrCreateRefForRole(this.byRoleRefToProperty, role, this.propertyGetter);
+    const ref = this.getOrCreateRefForRole(
+      this.byRoleRefToProperty,
+      role,
+      this.propertyGetter,
+    );
     return ref.value;
   }
 

vue-model-api/src/internal/handleChange.ts

@@ -9,15 +9,15 @@ type ChangeJS = org.modelix.model.client2.ChangeJS;
 
 export function handleChange(change: ChangeJS, cache: Cache<ReactiveINodeJS>) {
   const unreactiveNode = change.node;
-  const reacitveNode = cache.get(unreactiveNode);
-  if (reacitveNode === undefined) {
+  const reactiveNode = cache.get(unreactiveNode);
+  if (reactiveNode === undefined) {
     return;
   }
   if (change instanceof PropertyChanged) {
-    reacitveNode.triggerChangeInProperty(change.role);
+    reactiveNode.triggerChangeInProperty(change.role);
   } else if (change instanceof ReferenceChanged) {
-    reacitveNode.triggerChangeInReference(change.role);
+    reactiveNode.triggerChangeInReference(change.role);
   } else if (change instanceof ChildrenChanged) {
-    reacitveNode.triggerChangeInChild(change.role);
+    reactiveNode.triggerChangeInChild(change.role);
   }
 }

vue-model-api/src/internal/useLastPromiseEffect.ts

@@ -3,14 +3,14 @@ import { watchEffect } from "vue";
 /**
  * This function takes a `promiseEffect` callback and executes it every time its used reactive values are changed.
  *
- * If a promise is fullfilled, the `onfulfilled` call back is called with the value and aboolean,
+ * If a promise is fulfilled, the `onfulfilled` call back is called with the value and a boolean,
  * which indicates if the value is the result of the last create promise.
  *
  * If a promise is rejected, the `onrejected` call back is called with the reason and a boolean,
  * which indicates if the value is the result of the last create promise.
  *
- * This function is usefull, if you need to trigger a new promise every time some reavtive value changes and
- * then need to distinguashe if the value/error of the settled promise comes from the last started promise.
+ * This function is useful, if you need to trigger a new promise every time some reavtive value changes and
+ * then need to distinguish if the value/error of the settled promise comes from the last started promise.
  *
  * @param promiseEffect A function that may create a new promise.
  *
@@ -30,7 +30,7 @@ export function useLastPromiseEffect<ValueT>(
     const thisPromise = promiseEffect();
     lastStartedPromise = thisPromise;
     const isResultOfLastStartedPromise = () =>
-      // `lastStartedPromise` might be diffrent to `thisPromise`,
+      // `lastStartedPromise` might be different to `thisPromise`,
       // because this function gets called asynchronously, when `thisPromise` is settled.
       // In the meantime `promiseEffect()` might have been called again and assigned a new value to `lastStartedPromise`.
       lastStartedPromise == thisPromise;