mobx-keystone 1.20.0 → 1.22.0

package/src/wrappers/ArraySet.ts

@@ -1,156 +1,156 @@
-import { values } from "mobx"
-import { modelAction } from "../action/modelAction"
-import type { AnyModel } from "../model/BaseModel"
-import { Model } from "../model/Model"
-import { modelIdKey } from "../model/metadata"
-import { model } from "../modelShared/modelDecorator"
-import { idProp } from "../modelShared/prop"
-import { typesArray } from "../types/arrayBased/typesArray"
-import { tProp } from "../types/tProp"
-import { typesUnchecked } from "../types/utility/typesUnchecked"
-import { namespace } from "../utils"
-
-const arraySetBase = Model({
-  [modelIdKey]: idProp,
-  items: tProp(typesArray(typesUnchecked<any>()), () => []), // will be properly checked by types.arraySet(subType)
-}) as abstract new (
-  data: any
-) => AnyModel & {
-  readonly $: {
-    items: any[]
-  }
-  readonly items: any[]
-}
-
-/**
- * A set that is backed by an array.
- * Use `arraySet` to create it.
- */
-@model(`${namespace}/ArraySet`)
-// biome-ignore lint/suspicious/noUnsafeDeclarationMerging: model base defines these properties at runtime.
-export class ArraySet<V> extends arraySetBase implements Set<V> {
-  @modelAction
-  add(value: V): this {
-    const items = this.items
-
-    if (!items.includes(value)) {
-      items.push(value)
-    }
-    return this
-  }
-
-  @modelAction
-  clear(): void {
-    this.items.length = 0
-  }
-
-  @modelAction
-  delete(value: V): boolean {
-    const items = this.items
-
-    const index = items.indexOf(value)
-    if (index >= 0) {
-      items.splice(index, 1)
-      return true
-    } else {
-      return false
-    }
-  }
-
-  forEach(callbackfn: (value: V, value2: V, set: Set<V>) => void, thisArg?: any): void {
-    // we cannot use the set implementation since we need to pass this as set
-    const items = this.items
-    const len = items.length
-    for (let i = 0; i < len; i++) {
-      const k = items[i]
-      callbackfn.call(thisArg, k, k, this)
-    }
-  }
-
-  has(value: V): boolean {
-    return this.items.includes(value)
-  }
-
-  get size(): number {
-    return this.items.length
-  }
-
-  *keys(): ReturnType<Set<V>["keys"]> {
-    // yes, values
-    for (const value of values(this.items)) {
-      yield value as V
-    }
-  }
-
-  *values(): ReturnType<Set<V>["values"]> {
-    for (const value of values(this.items)) {
-      yield value as V
-    }
-  }
-
-  *entries(): ReturnType<Set<V>["entries"]> {
-    for (const v of this.items) {
-      yield [v, v]
-    }
-  }
-
-  [Symbol.iterator](): ReturnType<Set<V>[typeof Symbol.iterator]> {
-    return this.values()
-  }
-
-  readonly [Symbol.toStringTag] = "ArraySet"
-
-  union<U>(other: ReadonlySetLike<U>): Set<V | U> {
-    const s = new Set(this)
-    return s.union(other)
-  }
-
-  intersection<U>(other: ReadonlySetLike<U>): Set<V & U> {
-    const s = new Set(this)
-    return s.intersection(other)
-  }
-
-  difference<U>(other: ReadonlySetLike<U>): Set<V> {
-    const s = new Set(this)
-    return s.difference(other)
-  }
-
-  symmetricDifference<U>(other: ReadonlySetLike<U>): Set<V | U> {
-    const s = new Set(this)
-    return s.symmetricDifference(other)
-  }
-
-  isSubsetOf(other: ReadonlySetLike<unknown>): boolean {
-    const s = new Set(this)
-    return s.isSubsetOf(other)
-  }
-
-  isSupersetOf(other: ReadonlySetLike<unknown>): boolean {
-    const s = new Set(this)
-    return s.isSupersetOf(other)
-  }
-
-  isDisjointFrom(other: ReadonlySetLike<unknown>): boolean {
-    const s = new Set(this)
-    return s.isDisjointFrom(other)
-  }
-}
-
-export interface ArraySet<V> {
-  readonly $: {
-    items: V[]
-  }
-  readonly items: V[]
-}
-
-/**
- * Creates a new ArraySet model instance.
- *
- * @template V Value type.
- * @param [values] Optional initial values.
- */
-export function arraySet<V>(values?: ReadonlyArray<V> | null): ArraySet<V> {
-  const initialArr: V[] = values ? values.slice() : []
-
-  return new ArraySet({ items: initialArr })
-}
+import { values } from "mobx"
+import { modelAction } from "../action/modelAction"
+import type { AnyModel } from "../model/BaseModel"
+import { Model } from "../model/Model"
+import { modelIdKey } from "../model/metadata"
+import { model } from "../modelShared/modelDecorator"
+import { idProp } from "../modelShared/prop"
+import { typesArray } from "../types/arrayBased/typesArray"
+import { tProp } from "../types/tProp"
+import { typesUnchecked } from "../types/utility/typesUnchecked"
+import { namespace } from "../utils"
+
+const arraySetBase = Model({
+  [modelIdKey]: idProp,
+  items: tProp(typesArray(typesUnchecked<any>()), () => []), // will be properly checked by types.arraySet(subType)
+}) as abstract new (
+  data: any
+) => AnyModel & {
+  readonly $: {
+    items: any[]
+  }
+  readonly items: any[]
+}
+
+/**
+ * A set that is backed by an array.
+ * Use `arraySet` to create it.
+ */
+@model(`${namespace}/ArraySet`)
+// biome-ignore lint/suspicious/noUnsafeDeclarationMerging: model base defines these properties at runtime.
+export class ArraySet<V> extends arraySetBase implements Set<V> {
+  @modelAction
+  add(value: V): this {
+    const items = this.items
+
+    if (!items.includes(value)) {
+      items.push(value)
+    }
+    return this
+  }
+
+  @modelAction
+  clear(): void {
+    this.items.length = 0
+  }
+
+  @modelAction
+  delete(value: V): boolean {
+    const items = this.items
+
+    const index = items.indexOf(value)
+    if (index >= 0) {
+      items.splice(index, 1)
+      return true
+    } else {
+      return false
+    }
+  }
+
+  forEach(callbackfn: (value: V, value2: V, set: Set<V>) => void, thisArg?: any): void {
+    // we cannot use the set implementation since we need to pass this as set
+    const items = this.items
+    const len = items.length
+    for (let i = 0; i < len; i++) {
+      const k = items[i]
+      callbackfn.call(thisArg, k, k, this)
+    }
+  }
+
+  has(value: V): boolean {
+    return this.items.includes(value)
+  }
+
+  get size(): number {
+    return this.items.length
+  }
+
+  *keys(): ReturnType<Set<V>["keys"]> {
+    // yes, values
+    for (const value of values(this.items)) {
+      yield value as V
+    }
+  }
+
+  *values(): ReturnType<Set<V>["values"]> {
+    for (const value of values(this.items)) {
+      yield value as V
+    }
+  }
+
+  *entries(): ReturnType<Set<V>["entries"]> {
+    for (const v of this.items) {
+      yield [v, v]
+    }
+  }
+
+  [Symbol.iterator](): ReturnType<Set<V>[typeof Symbol.iterator]> {
+    return this.values()
+  }
+
+  readonly [Symbol.toStringTag] = "ArraySet"
+
+  union<U>(other: ReadonlySetLike<U>): Set<V | U> {
+    const s = new Set(this)
+    return s.union(other)
+  }
+
+  intersection<U>(other: ReadonlySetLike<U>): Set<V & U> {
+    const s = new Set(this)
+    return s.intersection(other)
+  }
+
+  difference<U>(other: ReadonlySetLike<U>): Set<V> {
+    const s = new Set(this)
+    return s.difference(other)
+  }
+
+  symmetricDifference<U>(other: ReadonlySetLike<U>): Set<V | U> {
+    const s = new Set(this)
+    return s.symmetricDifference(other)
+  }
+
+  isSubsetOf(other: ReadonlySetLike<unknown>): boolean {
+    const s = new Set(this)
+    return s.isSubsetOf(other)
+  }
+
+  isSupersetOf(other: ReadonlySetLike<unknown>): boolean {
+    const s = new Set(this)
+    return s.isSupersetOf(other)
+  }
+
+  isDisjointFrom(other: ReadonlySetLike<unknown>): boolean {
+    const s = new Set(this)
+    return s.isDisjointFrom(other)
+  }
+}
+
+export interface ArraySet<V> {
+  readonly $: {
+    items: V[]
+  }
+  readonly items: V[]
+}
+
+/**
+ * Creates a new ArraySet model instance.
+ *
+ * @template V Value type.
+ * @param [values] Optional initial values.
+ */
+export function arraySet<V>(values?: ReadonlyArray<V> | null): ArraySet<V> {
+  const initialArr: V[] = values ? values.slice() : []
+
+  return new ArraySet({ items: initialArr })
+}

package/src/wrappers/ObjectMap.ts

@@ -1,136 +1,155 @@
-import { entries, get, has, keys, remove, values } from "mobx"
-import { modelAction } from "../action/modelAction"
-import type { AnyModel } from "../model/BaseModel"
-import { Model } from "../model/Model"
-import { modelIdKey } from "../model/metadata"
-import { model } from "../modelShared/modelDecorator"
-import { idProp } from "../modelShared/prop"
-import { typesRecord } from "../types/objectBased/typesRecord"
-import { tProp } from "../types/tProp"
-import { typesUnchecked } from "../types/utility/typesUnchecked"
-import { namespace } from "../utils"
-import { setIfDifferent } from "../utils/setIfDifferent"
-
-const objectMapBase = Model({
-  [modelIdKey]: idProp,
-  items: tProp(typesRecord(typesUnchecked<any>()), () => ({})), // will be properly checked by types.objectMap(subType)
-}) as abstract new (
-  data: any
-) => AnyModel & {
-  readonly $: {
-    items: Record<string, any>
-  }
-  readonly items: Record<string, any>
-}
-
-/**
- * A map that is backed by an object-like map.
- * Use `objectMap` to create it.
- */
-@model(`${namespace}/ObjectMap`)
-// biome-ignore lint/suspicious/noUnsafeDeclarationMerging: model base defines these properties at runtime.
-export class ObjectMap<V> extends objectMapBase implements Map<string, V> {
-  @modelAction
-  clear(): void {
-    const items = this.items
-
-    const keys = Object.keys(items)
-    const len = keys.length
-    for (let i = 0; i < len; i++) {
-      const k = keys[i]
-      remove(items, k)
-    }
-  }
-
-  @modelAction
-  delete(key: string): boolean {
-    const hasKey = this.has(key)
-    if (hasKey) {
-      remove(this.items, key)
-      return true
-    } else {
-      return false
-    }
-  }
-
-  forEach(callbackfn: (value: V, key: string, map: Map<string, V>) => void, thisArg?: any): void {
-    // we cannot use the map implementation since we need to pass this as map
-    const items = this.items
-
-    const keys = Object.keys(items)
-    const len = keys.length
-    for (let i = 0; i < len; i++) {
-      const k = keys[i]
-      callbackfn.call(thisArg, items[k], k, this)
-    }
-  }
-
-  get(key: string): V | undefined {
-    return get(this.items, key)
-  }
-
-  has(key: string): boolean {
-    return has(this.items, key)
-  }
-
-  @modelAction
-  set(key: string, value: V): this {
-    setIfDifferent(this.items, key, value)
-    return this
-  }
-
-  get size(): number {
-    return keys(this.items).length
-  }
-
-  *keys(): ReturnType<Map<string, V>["keys"]> {
-    for (const key of keys(this.items)) {
-      yield key as string
-    }
-  }
-
-  *values(): ReturnType<Map<string, V>["values"]> {
-    for (const value of values(this.items)) {
-      yield value
-    }
-  }
-
-  *entries(): ReturnType<Map<string, V>["entries"]> {
-    for (const entry of entries(this.items)) {
-      yield entry
-    }
-  }
-
-  [Symbol.iterator](): ReturnType<Map<string, V>[typeof Symbol.iterator]> {
-    return this.entries()
-  }
-
-  readonly [Symbol.toStringTag] = "ObjectMap"
-}
-
-export interface ObjectMap<V> {
-  readonly $: {
-    items: Record<string, V>
-  }
-  readonly items: Record<string, V>
-}
-
-/**
- * Creates a new ObjectMap model instance.
- *
- * @template V Value type.
- * @param [entries] Optional initial values.
- */
-export function objectMap<V>(entries?: ReadonlyArray<readonly [string, V]> | null): ObjectMap<V> {
-  const initialObj: Record<string, V> = {}
-
-  if (entries) {
-    const len = entries.length
-    for (let i = 0; i < len; i++) {
-      const entry = entries[i]
-      initialObj[entry[0]] = entry[1]
-    }
-  }
-
-  return new ObjectMap({ items: initialObj })
-}
+import { entries, get, has, keys, remove, values } from "mobx"
+import { modelAction } from "../action/modelAction"
+import type { AnyModel } from "../model/BaseModel"
+import { Model } from "../model/Model"
+import { modelIdKey } from "../model/metadata"
+import { model } from "../modelShared/modelDecorator"
+import { idProp } from "../modelShared/prop"
+import { typesRecord } from "../types/objectBased/typesRecord"
+import { tProp } from "../types/tProp"
+import { typesUnchecked } from "../types/utility/typesUnchecked"
+import { namespace } from "../utils"
+import { setIfDifferent } from "../utils/setIfDifferent"
+
+const objectMapBase = Model({
+  [modelIdKey]: idProp,
+  items: tProp(typesRecord(typesUnchecked<any>()), () => ({})), // will be properly checked by types.objectMap(subType)
+}) as abstract new (
+  data: any
+) => AnyModel & {
+  readonly $: {
+    items: Record<string, any>
+  }
+  readonly items: Record<string, any>
+}
+
+/**
+ * A map that is backed by an object-like map.
+ * Use `objectMap` to create it.
+ */
+@model(`${namespace}/ObjectMap`)
+// biome-ignore lint/suspicious/noUnsafeDeclarationMerging: model base defines these properties at runtime.
+export class ObjectMap<V> extends objectMapBase implements Map<string, V> {
+  @modelAction
+  clear(): void {
+    const items = this.items
+
+    const keys = Object.keys(items)
+    const len = keys.length
+    for (let i = 0; i < len; i++) {
+      const k = keys[i]
+      remove(items, k)
+    }
+  }
+
+  @modelAction
+  delete(key: string): boolean {
+    const hasKey = this.has(key)
+    if (hasKey) {
+      remove(this.items, key)
+      return true
+    } else {
+      return false
+    }
+  }
+
+  forEach(callbackfn: (value: V, key: string, map: Map<string, V>) => void, thisArg?: any): void {
+    // we cannot use the map implementation since we need to pass this as map
+    const items = this.items
+
+    const keys = Object.keys(items)
+    const len = keys.length
+    for (let i = 0; i < len; i++) {
+      const k = keys[i]
+      callbackfn.call(thisArg, items[k], k, this)
+    }
+  }
+
+  get(key: string): V | undefined {
+    return get(this.items, key)
+  }
+
+  getOrInsert(key: string, defaultValue: V): V {
+    if (this.has(key)) {
+      return this.get(key) as V
+    }
+
+    this.set(key, defaultValue)
+    return defaultValue
+  }
+
+  getOrInsertComputed(key: string, callback: (key: string) => V): V {
+    if (this.has(key)) {
+      return this.get(key) as V
+    }
+
+    const value = callback(key)
+    this.set(key, value)
+    return value
+  }
+
+  has(key: string): boolean {
+    return has(this.items, key)
+  }
+
+  @modelAction
+  set(key: string, value: V): this {
+    setIfDifferent(this.items, key, value)
+    return this
+  }
+
+  get size(): number {
+    return keys(this.items).length
+  }
+
+  *keys(): ReturnType<Map<string, V>["keys"]> {
+    for (const key of keys(this.items)) {
+      yield key as string
+    }
+  }
+
+  *values(): ReturnType<Map<string, V>["values"]> {
+    for (const value of values(this.items)) {
+      yield value
+    }
+  }
+
+  *entries(): ReturnType<Map<string, V>["entries"]> {
+    for (const entry of entries(this.items)) {
+      yield entry
+    }
+  }
+
+  [Symbol.iterator](): ReturnType<Map<string, V>[typeof Symbol.iterator]> {
+    return this.entries()
+  }
+
+  readonly [Symbol.toStringTag] = "ObjectMap"
+}
+
+export interface ObjectMap<V> {
+  readonly $: {
+    items: Record<string, V>
+  }
+  readonly items: Record<string, V>
+}
+
+/**
+ * Creates a new ObjectMap model instance.
+ *
+ * @template V Value type.
+ * @param [entries] Optional initial values.
+ */
+export function objectMap<V>(entries?: ReadonlyArray<readonly [string, V]> | null): ObjectMap<V> {
+  const initialObj: Record<string, V> = {}
+
+  if (entries) {
+    const len = entries.length
+    for (let i = 0; i < len; i++) {
+      const entry = entries[i]
+      initialObj[entry[0]] = entry[1]
+    }
+  }
+
+  return new ObjectMap({ items: initialObj })
+}