@xyo-network/object 2.74.0

package/src/AsObjectFactory.ts

@@ -0,0 +1,49 @@
+import { assertEx } from '@xylabs/assert'
+
+import { ObjectTypeCheck, ObjectTypeConfig } from './IsObjectFactory'
+
+export const AsObjectFactory = {
+  // eslint-disable-next-line @typescript-eslint/ban-types
+  create: <T extends object>(typeCheck: ObjectTypeCheck<T>) => {
+    function func<TObject extends T>(
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      obj: object | undefined | null,
+      config?: ObjectTypeConfig,
+    ): TObject | undefined
+    function func<TObject extends T>(
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      obj: object | undefined | null,
+      assert: string | (() => string),
+      config?: ObjectTypeConfig,
+    ): TObject
+    function func<TObject extends T>(
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      obj: object | undefined | null,
+      assertOrConfig?: string | (() => string) | ObjectTypeConfig,
+      config?: ObjectTypeConfig,
+    ): TObject | undefined {
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      const noUndefined = (resolvedAssert: any): resolvedAssert is T => {
+        return !!resolvedAssert
+      }
+
+      if (obj === undefined) {
+        return undefined
+      }
+
+      if (obj === null) {
+        return undefined
+      }
+      const resolvedAssert = typeof assertOrConfig === 'object' ? undefined : assertOrConfig
+      const resolvedConfig = typeof assertOrConfig === 'object' ? assertOrConfig : config
+      const result = typeCheck(obj, resolvedConfig) ? obj : undefined
+
+      if (noUndefined(resolvedAssert)) {
+        return assertEx(result, typeof resolvedAssert === 'function' ? resolvedAssert() : resolvedAssert) as TObject
+      } else {
+        return result as TObject
+      }
+    }
+    return func
+  },
+}

package/src/EmptyObject.ts

@@ -0,0 +1 @@
+export type EmptyObject = { [key: string | number | symbol]: never }

package/src/IsObjectFactory.ts

@@ -0,0 +1,34 @@
+import { Logger } from '@xyo-network/logger'
+
+import { isType, ObjectTypeShape } from './isType'
+
+export interface ObjectTypeConfig {
+  log?: boolean | Logger
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/ban-types
+export type ObjectTypeCheck<T extends {} = {}> = (obj: any, config?: ObjectTypeConfig) => obj is T
+
+// eslint-disable-next-line @typescript-eslint/ban-types
+export class IsObjectFactory<T extends {}> {
+  create(shape?: ObjectTypeShape, additionalChecks?: ObjectTypeCheck[]): ObjectTypeCheck<T> {
+    return (obj, { log } = {}): obj is T => {
+      if (!obj || typeof obj !== 'object') {
+        return false
+      }
+      return (
+        //do primary check
+        Object.entries(shape ?? {}).reduce((prev, [key, type]) => {
+          const result = isType(obj[key], type)
+          if (!result && log) {
+            const logger = typeof log === 'object' ? log : console
+            logger.warn(`isType Failed: ${key}: ${type}`)
+          }
+          return prev && result
+        }, true) &&
+        //perform additional checks
+        (additionalChecks?.reduce((prev, check) => prev && check(obj, { log }), true) ?? true)
+      )
+    }
+  }
+}

package/src/ObjectWrapper.ts

@@ -0,0 +1,12 @@
+import { EmptyObject } from './EmptyObject'
+import { StringKeyObject } from './StringKeyObject'
+
+export abstract class ObjectWrapper<T extends EmptyObject = EmptyObject> {
+  readonly obj: T
+  constructor(obj: T) {
+    this.obj = obj
+  }
+  protected get stringKeyObj() {
+    return this.obj as StringKeyObject
+  }
+}

package/src/StringKeyObject.ts

@@ -0,0 +1 @@
+export type StringKeyObject = { [key: string]: unknown }

package/src/WithAdditional.ts

@@ -0,0 +1,3 @@
+import { AnyObject } from './AnyObject'
+
+export type WithAdditional<T extends AnyObject, TAdditional extends AnyObject | void = void> = TAdditional extends AnyObject ? T & TAdditional : T

package/src/asObject.ts

@@ -0,0 +1,5 @@
+import { AsObjectFactory } from './AsObjectFactory'
+import { isObject } from './isObject'
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export const asObject = (() => AsObjectFactory.create(<T>(obj: T): obj is T => isObject(obj)))()

package/src/index.ts

@@ -0,0 +1,10 @@
+export * from './AnyObject'
+export * from './asObject'
+export * from './AsObjectFactory'
+export * from './EmptyObject'
+export * from './isObject'
+export * from './IsObjectFactory'
+export * from './isType'
+export * from './ObjectWrapper'
+export * from './StringKeyObject'
+export * from './WithAdditional'

package/src/isObject.ts

@@ -0,0 +1,6 @@
+import { isType } from './isType'
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export const isObject = (value: any): value is Record<string | number | symbol, any> => {
+  return isType(value, 'object')
+}

package/src/isType.ts

@@ -0,0 +1,27 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+export type FieldType = 'string' | 'number' | 'object' | 'symbol' | 'symbol' | 'undefined' | 'null' | 'array' | 'function'
+
+export type ObjectTypeShape = Record<string | number | symbol, FieldType>
+
+export const isType = (value: unknown, expectedType: FieldType) => {
+  const typeofValue = typeof value
+  switch (expectedType) {
+    case 'array':
+      return Array.isArray(value)
+    case 'null':
+      return value === null
+    case 'undefined':
+      return value === undefined
+    case 'object': {
+      //nulls resolve to objects, so exclude them
+      if (value === null) {
+        return false
+      }
+      //arrays resolve to objects, so exclude them
+      return typeofValue === 'object' && !Array.isArray(value)
+    }
+    default:
+      return typeofValue === expectedType
+  }
+}

package/typedoc.json

@@ -0,0 +1,5 @@
+{
+  "$schema": "https://typedoc.org/schema.json",
+  "entryPoints": ["./src/index.ts"],
+  "tsconfig": "./tsconfig.typedoc.json"
+}