r-state-tree 0.4.6 → 0.5.0

package/dist/r-state-tree.js

@@ -1,5 +1,5 @@
 import { batch, Signal, signal, computed as computed$1, untracked, effect } from "@preact/signals-core";
-import { ReadonlySignal, Signal as Signal2, batch as batch2, effect as effect2, signal as signal2, untracked as untracked2 } from "@preact/signals-core";
+import { Signal as Signal2, batch as batch2, effect as effect2, signal as signal2, untracked as untracked2 } from "@preact/signals-core";
 var lib = {};
 var hasRequiredLib;
 function requireLib() {
@@ -16,6 +16,8 @@ var CommonCfgTypes = /* @__PURE__ */ ((CommonCfgTypes2) => {
 })(CommonCfgTypes || {});
 var ModelCfgTypes = /* @__PURE__ */ ((ModelCfgTypes2) => {
   ModelCfgTypes2["state"] = "state";
+  ModelCfgTypes2["stateShallow"] = "stateShallow";
+  ModelCfgTypes2["stateSignal"] = "stateSignal";
   ModelCfgTypes2["id"] = "id";
   ModelCfgTypes2["modelRef"] = "modelRef";
   return ModelCfgTypes2;
@@ -26,6 +28,8 @@ var StoreCfgTypes = /* @__PURE__ */ ((StoreCfgTypes2) => {
 })(StoreCfgTypes || {});
 var ObservableCfgTypes = /* @__PURE__ */ ((ObservableCfgTypes2) => {
   ObservableCfgTypes2["observable"] = "observable";
+  ObservableCfgTypes2["observableShallow"] = "observableShallow";
+  ObservableCfgTypes2["observableSignal"] = "observableSignal";
   ObservableCfgTypes2["computed"] = "computed";
   return ObservableCfgTypes2;
 })(ObservableCfgTypes || {});
@@ -42,6 +46,14 @@ const stateType = {
   type: "state"
   /* state */
 };
+const stateShallowType = {
+  type: "stateShallow"
+  /* stateShallow */
+};
+const stateSignalType = {
+  type: "stateSignal"
+  /* stateSignal */
+};
 const modelRefType = Object.assign(
   function(childType2) {
     return { type: "modelRef", childType: childType2 };
@@ -84,6 +96,12 @@ function getPropertyType(key, obj) {
     switch (config.type) {
       case ObservableCfgTypes.computed:
         return "computed";
+      case ObservableCfgTypes.observableShallow:
+      case ModelCfgTypes.stateShallow:
+        return "observableShallow";
+      case ObservableCfgTypes.observableSignal:
+      case ModelCfgTypes.stateSignal:
+        return "observableSignal";
       case ModelCfgTypes.state:
       case ObservableCfgTypes.observable:
       case ModelCfgTypes.id:
@@ -352,6 +370,7 @@ class ObjectAdministration extends Administration {
     }
     switch (type) {
       case "observable":
+      case "observableShallow":
       case "action": {
         if (key in this.source) {
           this.valuesMap.reportObserved(key, this.source[key]);
@@ -363,8 +382,21 @@ class ObjectAdministration extends Administration {
         if (type === "observable") {
           return getObservable(this.get(key));
         }
+        if (type === "observableShallow") {
+          return getShallowObservable(this.get(key));
+        }
         return getAction(this.get(key));
       }
+      case "observableSignal": {
+        if (key in this.source) {
+          this.valuesMap.reportObserved(key, this.source[key]);
+        }
+        this.atom.reportObserved();
+        if (this.atom.observing) {
+          this.hasMap.reportObserved(key);
+        }
+        return this.get(key);
+      }
       case "computed": {
         return this.callComputed(key);
       }
@@ -572,13 +604,31 @@ function createComputed(fn, context = null) {
     }
   };
 }
-function observable(value, context) {
+function observableImpl(value, context) {
   if (context && typeof context === "object" && "kind" in context) {
     context.metadata[context.name] = { type: "observable" };
     return value;
   }
   return getObservable(value);
 }
+function shallowDecorator(value, context) {
+  if (context && typeof context === "object" && "kind" in context) {
+    context.metadata[context.name] = { type: "observableShallow" };
+    return value;
+  }
+  throw new Error("observable.shallow can only be used as a decorator");
+}
+function signalDecorator(value, context) {
+  if (context && typeof context === "object" && "kind" in context) {
+    context.metadata[context.name] = { type: "observableSignal" };
+    return value;
+  }
+  throw new Error("observable.signal can only be used as a decorator");
+}
+const observable = Object.assign(observableImpl, {
+  shallow: shallowDecorator,
+  signal: signalDecorator
+});
 function computed(value, context) {
   if (context && typeof context === "object" && "kind" in context) {
     context.metadata[context.name] = { type: "computed" };
@@ -790,6 +840,9 @@ class CollectionAdministration extends Administration {
     const value = sourceMap.get(targetKey) ?? sourceMap.get(key);
     if (has) {
       this.valuesMap.reportObserved(key, value);
+      if (isShallowObservable(this.proxy)) {
+        return value;
+      }
       return getObservable(value);
     }
     return void 0;
@@ -978,6 +1031,9 @@ class ArrayAdministration extends Administration {
   get(index) {
     this.atom.reportObserved();
     this.valuesMap.reportObserved(index, this.source[index]);
+    if (isShallowObservable(this.proxy)) {
+      return this.source[index];
+    }
     return getObservable(this.source[index]);
   }
   set(index, newValue) {
@@ -1243,6 +1299,39 @@ function getObservable(value) {
   }
   return value;
 }
+const shallowObservables = /* @__PURE__ */ new WeakSet();
+function isShallowObservable(obj) {
+  if (!obj || typeof obj !== "object") return false;
+  return shallowObservables.has(obj);
+}
+function getShallowObservable(value) {
+  if (!value) {
+    return value;
+  }
+  const existingAdm = getAdministration(value);
+  if (existingAdm) {
+    return existingAdm.proxy;
+  }
+  if ((typeof value === "object" || typeof value === "function") && !Object.isFrozen(value)) {
+    const obj = value;
+    let Adm = null;
+    if (Array.isArray(obj)) {
+      Adm = ArrayAdministration;
+    } else if (obj instanceof Map || obj instanceof WeakMap) {
+      Adm = CollectionAdministration;
+    } else if (obj instanceof Set || obj instanceof WeakSet) {
+      Adm = CollectionAdministration;
+    }
+    if (Adm) {
+      const adm = new Adm(obj);
+      administrationMap.set(adm.proxy, adm);
+      administrationMap.set(adm.source, adm);
+      shallowObservables.add(adm.proxy);
+      return adm.proxy;
+    }
+  }
+  return value;
+}
 function isObservable(obj) {
   if (!obj || typeof obj !== "object") return false;
   const adm = getAdministration(obj);
@@ -1316,6 +1405,33 @@ function getDiff(o1, o2, getConfig) {
   }
   return Object.keys(diff).length > 0 ? diff : null;
 }
+const MAX_MOUNT_DEPTH = 100;
+const mountingStack = [];
+function formatMountFrame(frame) {
+  const childSegment = frame.childName === void 0 ? "" : `.${String(frame.childName)}`;
+  return `${frame.storeName}${childSegment}`;
+}
+function formatMountChain(frame) {
+  const chain = [...mountingStack, frame];
+  const maxParts = 6;
+  if (chain.length > maxParts) {
+    const start = chain.slice(0, 3);
+    const end = chain.slice(-2);
+    return [
+      ...start,
+      { storeName: "...", modelsKeys: [], childName: void 0 },
+      ...end
+    ].map(formatMountFrame).join(" -> ");
+  }
+  return chain.map(formatMountFrame).join(" -> ");
+}
+function createCircularMountError(frame) {
+  const chain = formatMountChain(frame);
+  const models = frame.modelsKeys.length === 0 ? "no models provided" : `models: ${frame.modelsKeys.join(", ")}`;
+  return new Error(
+    `r-state-tree: detected circular store/model creation while mounting ${chain} (using ${models}). Passing models into child stores during mount can create recursive wiring. Move child store/model creation into storeDidMount or break the cycle.`
+  );
+}
 function updateProps(props, newProps) {
   untracked(() => {
     batch(() => {
@@ -1335,6 +1451,35 @@ function updateProps(props, newProps) {
 function getStoreAdm(store) {
   return getAdministration(store);
 }
+function validateStoreChildValue(value, propertyName) {
+  if (value === null || value === void 0) {
+    return;
+  }
+  if (Array.isArray(value)) {
+    const invalidItem = value.find(
+      (item) => item !== null && (typeof item !== "object" || !("Type" in item) || !("props" in item) || typeof item.Type !== "function" || typeof item.props !== "object")
+    );
+    if (invalidItem !== void 0) {
+      throw new Error(
+        `r-state-tree: child property '${String(
+          propertyName
+        )}' must be a StoreElement ({ Type, props, key }), an array of StoreElements, or null/undefined. Found invalid array item: ${typeof invalidItem}`
+      );
+    }
+    return;
+  }
+  if (typeof value === "object" && value !== null && "Type" in value && "props" in value) {
+    const element = value;
+    if (typeof element.Type === "function" && typeof element.props === "object") {
+      return;
+    }
+  }
+  throw new Error(
+    `r-state-tree: child property '${String(
+      propertyName
+    )}' must be a StoreElement ({ Type, props, key }), an array of StoreElements, or null/undefined. Found: ${typeof value}`
+  );
+}
 class StoreAdministration extends PreactObjectAdministration {
   static proxyTraps = Object.assign(
     {},
@@ -1402,7 +1547,7 @@ class StoreAdministration extends PreactObjectAdministration {
         }
       });
       childStoreData.value.set(stores);
-      stores.forEach((s) => getStoreAdm(s).mount(this));
+      stores.forEach((s) => getStoreAdm(s).mount(this, name));
       return stores;
     }
     const newStores = /* @__PURE__ */ new Set();
@@ -1453,7 +1598,7 @@ class StoreAdministration extends PreactObjectAdministration {
       batch(() => childStoreData.value.set(stores));
     }
     removedStores.forEach((s) => getStoreAdm(s).unmount());
-    newStores.forEach((s) => getStoreAdm(s).mount(this));
+    newStores.forEach((s) => getStoreAdm(s).mount(this, name));
     return stores;
   }
   setSingleStore(name, element) {
@@ -1472,7 +1617,7 @@ class StoreAdministration extends PreactObjectAdministration {
       }
       const childStore = this.createChildStore(element);
       batch(() => childStoreData.value.set(childStore));
-      getStoreAdm(childStore).mount(this);
+      getStoreAdm(childStore).mount(this, name);
       return childStore;
     } else {
       batch(() => updateProps(oldStore.props, props));
@@ -1484,6 +1629,7 @@ class StoreAdministration extends PreactObjectAdministration {
     const storeElement = childStoreData.listener.track(
       () => childStoreData.computed.get()
     );
+    validateStoreChildValue(storeElement, name);
     Array.isArray(storeElement) ? this.setStoreList(name, storeElement) : this.setSingleStore(name, storeElement);
   }
   getComputedGetter(name) {
@@ -1504,6 +1650,7 @@ class StoreAdministration extends PreactObjectAdministration {
     const storeElement = childStoreData.listener.track(
       () => childStoreData.computed.get()
     );
+    validateStoreChildValue(storeElement, name);
     Array.isArray(storeElement) ? this.setStoreList(name, storeElement) : this.setSingleStore(name, storeElement);
     return childStoreData.value.get();
   }
@@ -1513,6 +1660,7 @@ class StoreAdministration extends PreactObjectAdministration {
       return this.initializeStore(name);
     } else {
       const storeElement = untracked(() => childStoreData.computed.get());
+      validateStoreChildValue(storeElement, name);
       Array.isArray(storeElement) ? this.setStoreList(name, storeElement) : this.setSingleStore(name, storeElement);
       return childStoreData.value.get();
     }
@@ -1561,18 +1709,36 @@ class StoreAdministration extends PreactObjectAdministration {
     this.reactionsUnsub.push(unsub);
     return unsub;
   }
-  mount(parent = null) {
-    this.parent = parent || null;
-    this.childStoreDataMap.forEach(({ value }) => {
-      const stores = value.get();
-      if (Array.isArray(stores)) {
-        stores?.forEach((s) => getStoreAdm(s)?.mount(this));
-      } else if (stores) {
-        getStoreAdm(stores)?.mount(this);
+  mount(parent = null, childName) {
+    const frame = {
+      storeName: this.proxy.constructor.name || "Store",
+      childName,
+      modelsKeys: Object.keys(this.proxy.props?.models ?? {})
+    };
+    if (mountingStack.length + 1 > MAX_MOUNT_DEPTH) {
+      throw createCircularMountError(frame);
+    }
+    mountingStack.push(frame);
+    try {
+      this.parent = parent || null;
+      this.childStoreDataMap.forEach(({ value }, name) => {
+        const stores = value.get();
+        if (Array.isArray(stores)) {
+          stores?.forEach((s) => getStoreAdm(s)?.mount(this, name));
+        } else if (stores) {
+          getStoreAdm(stores)?.mount(this, name);
+        }
+      });
+      this.mounted = true;
+      batch(() => this.proxy.storeDidMount?.());
+    } catch (error) {
+      if (error instanceof RangeError && /call stack/i.test(error.message)) {
+        throw createCircularMountError(frame);
       }
-    });
-    this.mounted = true;
-    batch(() => this.proxy.storeDidMount?.());
+      throw error;
+    } finally {
+      mountingStack.pop();
+    }
   }
   unmount() {
     this.proxy.storeWillUnmount?.();
@@ -1890,6 +2056,30 @@ function getSnapshotRefId(snapshot) {
   }
   return snapshot[keys[0]];
 }
+function validateModelChildValue(value, propertyName) {
+  if (value === null || value === void 0) {
+    return;
+  }
+  if (value instanceof Model) {
+    return;
+  }
+  if (Array.isArray(value)) {
+    const invalidItem = value.find((item) => !(item instanceof Model));
+    if (invalidItem !== void 0) {
+      throw new Error(
+        `r-state-tree: child property '${String(
+          propertyName
+        )}' must be a Model instance, an array of Model instances, or null/undefined. Found invalid array item: ${typeof invalidItem}`
+      );
+    }
+    return;
+  }
+  throw new Error(
+    `r-state-tree: child property '${String(
+      propertyName
+    )}' must be a Model instance, an array of Model instances, or null/undefined. Found: ${typeof value}`
+  );
+}
 class ModelAdministration extends PreactObjectAdministration {
   static proxyTraps = Object.assign(
     {},
@@ -1923,6 +2113,7 @@ class ModelAdministration extends PreactObjectAdministration {
               return true;
             }
             case CommonCfgTypes.child: {
+              validateModelChildValue(value, name);
               if (Array.isArray(value)) {
                 adm.setModels(name, value);
                 return true;
@@ -1935,7 +2126,9 @@ class ModelAdministration extends PreactObjectAdministration {
               adm.setId(name, value);
               break;
             }
-            case ModelCfgTypes.state: {
+            case ModelCfgTypes.state:
+            case ModelCfgTypes.stateShallow:
+            case ModelCfgTypes.stateSignal: {
               adm.setState(name, value);
               break;
             }
@@ -2029,6 +2222,7 @@ class ModelAdministration extends PreactObjectAdministration {
     }
   }
   setModel(name, newModel) {
+    validateModelChildValue(newModel, name);
     const currentValue = this.proxy[name];
     if (currentValue === newModel) {
       return;
@@ -2048,6 +2242,7 @@ class ModelAdministration extends PreactObjectAdministration {
     }
   }
   setModels(name, newModelsSource) {
+    validateModelChildValue(newModelsSource, name);
     const newModels = createObservableWithCustomAdministration(
       [],
       ChildModelsAdministration
@@ -2203,6 +2398,8 @@ class ModelAdministration extends PreactObjectAdministration {
     return Object.keys(this.configuration).reduce((json, key) => {
       switch (this.configuration[key].type) {
         case ModelCfgTypes.state:
+        case ModelCfgTypes.stateShallow:
+        case ModelCfgTypes.stateSignal:
         case ModelCfgTypes.id:
           json[key] = clone(getSource(this.proxy[key]));
           break;
@@ -2268,6 +2465,8 @@ class ModelAdministration extends PreactObjectAdministration {
         const value = snapshot[key];
         switch (type) {
           case ModelCfgTypes.state:
+          case ModelCfgTypes.stateShallow:
+          case ModelCfgTypes.stateSignal:
             this.proxy[key] = value;
             break;
           case ModelCfgTypes.modelRef:
@@ -2483,11 +2682,13 @@ const child = makeChildDecorator(childType);
 const modelRef = makeChildDecorator(modelRefType);
 const model = makeDecorator(modelType);
 const id = makeDecorator(idType);
-const state = makeDecorator(stateType);
+const state = Object.assign(makeDecorator(stateType), {
+  shallow: makeDecorator(stateShallowType),
+  signal: makeDecorator(stateSignalType)
+});
 export {
   Model,
   Observable,
-  ReadonlySignal,
   Signal2 as Signal,
   Store,
   applySnapshot,

package/dist/store/Store.d.ts

@@ -1,4 +1,4 @@
-import { Props, StoreProps, StoreConfiguration } from "../types";
+import type { Props, StoreProps, StoreConfiguration } from "../types";
 export declare function allowNewStore<T>(fn: () => T): T;
 type CreateStoreProps<T extends Record<string, any>> = {
     [K in keyof T as undefined extends T[K] ? K : never]?: T[K] extends infer U ? U extends undefined ? never : undefined extends U ? U | undefined : U : never;

package/dist/store/StoreAdministration.d.ts

@@ -1,6 +1,6 @@
 import { PreactObjectAdministration as ObjectAdministration } from "../observables";
-import Store from "./Store";
-import { StoreConfiguration, Props } from "../types";
+import type Store from "./Store";
+import type { StoreConfiguration, Props } from "../types";
 export declare function updateProps(props: Props, newProps: Props): void;
 export declare function getStoreAdm(store: Store): StoreAdministration;
 export declare class StoreAdministration<StoreType extends Store = Store> extends ObjectAdministration<Store> {
@@ -25,6 +25,6 @@ export declare class StoreAdministration<StoreType extends Store = Store> extend
     getContextValue<T>(contextId: symbol, provideSymbol: symbol, defaultValue: T | undefined, hasDefault: boolean): T;
     private lookupContextValue;
     reaction<T>(track: () => T, callback: (a: T) => void): () => void;
-    mount(parent?: StoreAdministration | null): void;
+    mount(parent?: StoreAdministration | null, childName?: PropertyKey): void;
     unmount(): void;
 }

package/dist/types.d.ts

@@ -1,5 +1,5 @@
-import Store from "./store/Store";
-import Model from "./model/Model";
+import type Store from "./store/Store";
+import type Model from "./model/Model";
 export type StoreElement = {
     Type: new (...args: unknown[]) => Store;
     props: Props;
@@ -34,6 +34,8 @@ export declare enum CommonCfgTypes {
 }
 export declare enum ModelCfgTypes {
     state = "state",
+    stateShallow = "stateShallow",
+    stateSignal = "stateSignal",
     id = "id",
     modelRef = "modelRef"
 }
@@ -42,6 +44,8 @@ export declare enum StoreCfgTypes {
 }
 export declare enum ObservableCfgTypes {
     observable = "observable",
+    observableShallow = "observableShallow",
+    observableSignal = "observableSignal",
     computed = "computed"
 }
 export type ConfigurationTypes = CommonCfgTypes | ModelCfgTypes | StoreCfgTypes | ObservableCfgTypes;
@@ -70,11 +74,15 @@ export declare const childType: ((childType: Function) => ConfigurationType) & {
     type: CommonCfgTypes;
 };
 export declare const stateType: ConfigurationType;
+export declare const stateShallowType: ConfigurationType;
+export declare const stateSignalType: ConfigurationType;
 export declare const modelRefType: ((childType: Function) => ConfigurationType) & {
     type: ModelCfgTypes;
 };
 export declare const idType: ConfigurationType;
 export declare const modelType: ConfigurationType;
 export declare const observableType: ConfigurationType;
+export declare const observableShallowType: ConfigurationType;
+export declare const observableSignalType: ConfigurationType;
 export declare const computedType: ConfigurationType;
 export {};

package/dist/utils.d.ts

@@ -1,4 +1,4 @@
-import { ModelConfiguration } from "./types";
+import type { ModelConfiguration } from "./types";
 export declare function getPropertyDescriptor(obj: object, key: PropertyKey): PropertyDescriptor | undefined;
 export declare function getParentConstructor(Ctor: Function | undefined): Function | undefined;
 export declare function clone<T>(val: T): T;

package/package.json

@@ -1,59 +1,58 @@
 {
-	"name": "r-state-tree",
-	"version": "0.4.6",
-	"description": "reactive state management library",
-	"main": "dist/r-state-tree.cjs",
-	"module": "dist/r-state-tree.js",
-	"types": "dist/index.d.ts",
-	"exports": {
-		".": {
-			"types": "./dist/index.d.ts",
-			"import": "./dist/r-state-tree.js",
-			"require": "./dist/r-state-tree.cjs"
-		}
-	},
-	"files": [
-		"dist/*",
-		"README.md",
-		"LICENSE"
-	],
-	"scripts": {
-		"test": "vitest run",
-		"test:watch": "vitest",
-		"test:cover": "vitest run --coverage",
-		"build": "vite build && pnpm run build:types",
-		"build:types": "tsc --emitDeclarationOnly",
-		"lint": "eslint ./src ./tests --ext .ts",
-		"format": "prettier --cache --write \"src/**/*.ts\" \"tests/**/*.ts\"",
-		"prepublishOnly": "pnpm run build"
-	},
-	"repository": {
-		"type": "git",
-		"url": "git+https://github.com/melnikov-s/r-state-tree.git"
-	},
-	"author": "Sergey Melnikov",
-	"license": "MIT",
-	"bugs": {
-		"url": "https://github.com/melnikov-s/r-state-tree/issues"
-	},
-	"homepage": "https://github.com/melnikov-s/r-state-tree#readme",
-	"devDependencies": {
-		"@tsmetadata/polyfill": "^1.1.3",
-		"@typescript-eslint/eslint-plugin": "^5.8.1",
-		"@typescript-eslint/parser": "^5.8.1",
-		"eslint": "^8.5.0",
-		"eslint-config-airbnb": "^19.0.4",
-		"eslint-config-prettier": "^8.3.0",
-		"eslint-import-resolver-typescript": "^2.5.0",
-		"eslint-plugin-import": "^2.25.3",
-		"eslint-plugin-prettier": "^4.0.0",
-		"prettier": "^2.8.4",
-		"tslib": "^2.5.0",
-		"typescript": "5.9.3",
-		"vite": "7.1.9",
-		"vitest": "3.2.4"
-	},
-	"dependencies": {
-		"@preact/signals-core": "^1.12.1"
-	}
-}
+  "name": "r-state-tree",
+  "version": "0.5.0",
+  "description": "reactive state management library",
+  "main": "dist/r-state-tree.cjs",
+  "module": "dist/r-state-tree.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/r-state-tree.js",
+      "require": "./dist/r-state-tree.cjs"
+    }
+  },
+  "files": [
+    "dist/*",
+    "README.md",
+    "LICENSE"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/melnikov-s/r-state-tree.git"
+  },
+  "author": "Sergey Melnikov",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/melnikov-s/r-state-tree/issues"
+  },
+  "homepage": "https://github.com/melnikov-s/r-state-tree#readme",
+  "devDependencies": {
+    "@tsmetadata/polyfill": "^1.1.3",
+    "@typescript-eslint/eslint-plugin": "^5.8.1",
+    "@typescript-eslint/parser": "^5.8.1",
+    "eslint": "^8.5.0",
+    "eslint-config-airbnb": "^19.0.4",
+    "eslint-config-prettier": "^8.3.0",
+    "eslint-import-resolver-typescript": "^2.5.0",
+    "eslint-plugin-import": "^2.25.3",
+    "eslint-plugin-prettier": "^4.0.0",
+    "prettier": "^2.8.4",
+    "tslib": "^2.5.0",
+    "typescript": "5.9.3",
+    "vite": "7.1.9",
+    "vitest": "3.2.4"
+  },
+  "dependencies": {
+    "@preact/signals-core": "^1.12.1"
+  },
+  "scripts": {
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:cover": "vitest run --coverage",
+    "build": "vite build && pnpm run build:types",
+    "build:types": "tsc --emitDeclarationOnly",
+    "lint": "eslint ./src ./tests --ext .ts",
+    "format": "prettier --cache --write \"src/**/*.ts\" \"tests/**/*.ts\""
+  }
+}