@planet-matrix/mobius-model 0.3.0 → 0.5.0

package/src/basic/number.ts

@@ -0,0 +1,178 @@
+/**
+ * Normalize a value to a 0-1 range based on min and max.
+ *
+ * @example
+ * ```
+ * // Expect: 0.5
+ * const example1 = normalize(5, 0, 10)
+ * // Expect: 0
+ * const example2 = normalize(2, 2, 6)
+ * ```
+ */
+export const normalize = (value: number, min: number, max: number): number => {
+  if (min === max) {
+    throw new Error("Min and max value are the same.")
+  }
+  if (value < min || value > max) {
+    throw new Error(`Value ${value} is not in the range of ${min} to ${max}.`)
+  }
+  return (value - min) / (max - min)
+}
+
+/**
+ * Check if a number is even.
+ *
+ * @example
+ * ```
+ * // Expect: true
+ * const example1 = isEven(10)
+ * // Expect: false
+ * const example2 = isEven(7)
+ * ```
+ */
+export const isEven = (x: number): boolean => x % 2 === 0
+
+/**
+ * Check if a number is odd.
+ *
+ * @example
+ * ```
+ * // Expect: true
+ * const example1 = isOdd(7)
+ * // Expect: false
+ * const example2 = isOdd(10)
+ * ```
+ */
+export const isOdd = (x: number): boolean => x % 2 !== 0
+
+/**
+ * Clamp a number to a maximum value.
+ *
+ * @example
+ * ```
+ * // Expect: 5
+ * const example1 = maxTo(5, 10)
+ * // Expect: 3
+ * const example2 = maxTo(5, 3)
+ * ```
+ */
+export const maxTo = (max: number, x: number): number => x > max ? max : x
+
+/**
+ * Clamp a number to a minimum value.
+ *
+ * @example
+ * ```
+ * // Expect: 5
+ * const example1 = minTo(5, 3)
+ * // Expect: 8
+ * const example2 = minTo(5, 8)
+ * ```
+ */
+export const minTo = (min: number, x: number): number => x < min ? min : x
+
+/**
+ * Get the smaller of two numbers.
+ *
+ * @example
+ * ```
+ * // Expect: 2
+ * const example1 = minOf(2, 9)
+ * // Expect: -1
+ * const example2 = minOf(5, -1)
+ * ```
+ */
+export const minOf = (x: number, y: number): number => x < y ? x : y
+
+/**
+ * Get the larger of two numbers.
+ *
+ * @example
+ * ```
+ * // Expect: 9
+ * const example1 = maxOf(2, 9)
+ * // Expect: 5
+ * const example2 = maxOf(5, -1)
+ * ```
+ */
+export const maxOf = (x: number, y: number): number => x > y ? x : y
+
+/**
+ * Clamp a number between two bounds.
+ *
+ * @example
+ * ```
+ * // Expect: 5
+ * const example1 = between(0, 10, 5)
+ * // Expect: 0
+ * const example2 = between(0, 10, -3)
+ * ```
+ */
+export const between = (a: number, b: number, x: number): number => {
+  const min = minOf(a, b)
+  const max = maxOf(a, b)
+  return x < min ? min : (x > max ? max : x)
+}
+
+/**
+ * Get a random integer between min and max, inclusive.
+ *
+ * @example
+ * ```
+ * // Expect: 4
+ * const example1 = randomBetween(4, 4)
+ * // Expect: 10
+ * const example2 = randomBetween(10, 10)
+ * ```
+ */
+export const randomBetween = (min: number, max: number): number => {
+  return Math.floor(Math.random() * (max - min + 1) + min)
+}
+
+/**
+ * Get a random integer between two values, regardless of order, inclusive.
+ *
+ * @example
+ * ```
+ * // Expect: 4
+ * const example1 = randomIntBetween(4, 4)
+ * // Expect: 10
+ * const example2 = randomIntBetween(10, 10)
+ * ```
+ */
+export const randomIntBetween = (a: number, b: number): number => {
+  const min = minOf(a, b)
+  const max = maxOf(a, b)
+  return Math.floor(Math.random() * (max - min + 1)) + min
+}
+
+export interface NumberConstraints {
+  min?: number | undefined
+  max?: number | undefined
+  step?: number | undefined
+}
+
+/**
+ * Constrain a number by step size and min/max bounds.
+ *
+ * @example
+ * ```
+ * // Expect: 10
+ * const example1 = constrainNumber(12, { step: 5, max: 10 })
+ * // Expect: 3
+ * const example2 = constrainNumber(2.6, { step: 0.5, min: 3 })
+ * ```
+ */
+export const constrainNumber = (value: number, constraints: NumberConstraints): number => {
+  let constrainedValue = value
+  if (constraints.step !== undefined) {
+    constrainedValue = Math.round(constrainedValue / constraints.step) * constraints.step
+  }
+  if (constraints.min !== undefined) {
+    constrainedValue = Math.max(constraints.min, constrainedValue)
+  }
+  if (constraints.max !== undefined) {
+    constrainedValue = Math.min(constraints.max, constrainedValue)
+  }
+  return constrainedValue
+}

package/src/basic/object.ts

@@ -0,0 +1,140 @@
+import type { AnyRecord } from "../type/index.ts"
+import { isDate } from "./is.ts"
+
+/**
+ * Return a new object that includes only the specified keys from the source object.
+ *
+ * @example
+ * ```
+ * // Expect: { a: 1, c: 3 }
+ * const example1 = includeFields({ a: 1, b: 2, c: 3 }, ["a", "c"])
+ * // Expect: {}
+ * const example2 = includeFields(null, ["a"])
+ * ```
+ */
+export const includeFields = <T extends AnyRecord, K extends keyof T>(
+  object: T | null | undefined,
+  keys: K[],
+): Pick<T, K> => {
+  if (object === null || object === undefined) {
+    // oxlint-disable-next-line no-unsafe-type-assertion
+    return {} as Pick<T, K>
+  }
+  const newObject: Partial<Pick<T, K>> = {} // 初始化一个部分类型的对象
+  keys.forEach((key) => {
+    if (key in object) {
+      newObject[key] = object[key]
+    }
+  })
+  // oxlint-disable-next-line no-unsafe-type-assertion
+  return newObject as Pick<T, K> // 使用正确的变量名并断言返回类型
+}
+
+/**
+ * Return a new object that excludes the specified keys from the source object.
+ *
+ * @example
+ * ```
+ * // Expect: { a: 1 }
+ * const example1 = excludeFields({ a: 1, b: 2 }, ["b"])
+ * // Expect: {}
+ * const example2 = excludeFields(undefined, ["a"])
+ * ```
+ */
+export const excludeFields = <T extends AnyRecord, K extends keyof T>(
+  object: T | null | undefined,
+  keys: K[],
+): Omit<T, K> => {
+  if (object === null || object === undefined) {
+    // oxlint-disable-next-line no-unsafe-type-assertion
+    return {} as Omit<T, K>
+  }
+  const newObject: Partial<T> = { ...object } // 创建原对象的浅拷贝
+  keys.forEach((key) => {
+    // oxlint-disable-next-line no-dynamic-delete
+    delete newObject[key] // 删除指定的键
+  })
+  // oxlint-disable-next-line no-unsafe-type-assertion
+  return newObject as Omit<T, K> // 使用Omit类型确保返回的类型反映了被排除的键
+}
+
+/**
+ * Convert all Date fields in an object to number.
+ *
+ * @example
+ * ```before
+ * type Obj = {
+ *   createdAt: Date,
+ * }
+ * ```
+ * ```after
+ * type Obj = {
+ *   createdAt: number,
+ * }
+ * ```
+ *
+ * @example
+ * ```before
+ * type Obj = {
+ *   createdAt: Date | undefined,
+ * }
+ * ```
+ * ```after
+ * type Obj = {
+ *   createdAt: number | undefined,
+ * }
+ * ```
+ *
+ * @example
+ * ```before
+ * type Obj = {
+ *   createdAt: Date | null,
+ * }
+ * ```
+ * ```after
+ * type Obj = {
+ *   createdAt: number | null,
+ * }
+ * ```
+ */
+export type ObjectDateFieldsToNumber<O extends object> = {
+  [K in keyof O]: O[K] extends Date
+  ? number
+  : (
+    O[K] extends Date | undefined
+    ? number | undefined
+    :
+    (O[K] extends Date | null
+      ? number | null
+      : (
+        O[K] extends object
+        ? ObjectDateFieldsToNumber<O[K]>
+        : O[K]
+      )
+    )
+  )
+}
+/**
+ * Convert all Date fields in an object to number.
+ *
+ * @example
+ * ```
+ * const obj = { createdAt: new Date() };
+ * const result = objectDateFieldsToNumber(obj);
+ * // Expect: { createdAt: 1712345678901 }
+ * ```
+ */
+export const objectDateFieldsToNumber = <O extends Record<string | number | symbol, unknown>>(
+  obj: O
+): ObjectDateFieldsToNumber<O> => {
+  // oxlint-disable-next-line guard-for-in
+  for (const key in obj) {
+    const value = obj[key];
+    if (isDate(value)) {
+      // oxlint-disable-next-line no-unsafe-type-assertion
+      obj[key] = value.getTime() as O[Extract<keyof O, string>]
+    }
+  }
+  // oxlint-disable-next-line no-unsafe-type-assertion
+  return obj as ObjectDateFieldsToNumber<O>
+}