@xylabs/object 2.88.3

package/src/Base.ts

@@ -0,0 +1,23 @@
+import { Logger } from '@xylabs/logger'
+
+import { EmptyObject } from './EmptyObject'
+
+export type BaseParamsFields = {
+  logger?: Logger
+}
+
+export type BaseParams<TAdditionalParams extends EmptyObject | void = void> = TAdditionalParams extends EmptyObject
+  ? BaseParamsFields & TAdditionalParams
+  : BaseParamsFields
+
+export abstract class Base<TParams extends BaseParams = BaseParams> {
+  static defaultLogger?: Logger
+
+  constructor(readonly params: TParams) {
+    params.logger?.debug(`Base constructed [${Object(this).name}]`)
+  }
+
+  protected get logger() {
+    return this.params?.logger ?? Base.defaultLogger
+  }
+}

package/src/EmptyObject.ts

@@ -0,0 +1,8 @@
+/**
+ * An empty object, which means that it does enforce the set of field names, defaulting to an empty set until
+ * extended from, which then adds only those additional fields
+ */
+
+export type EmptyObject<T extends object = object> = { [K in keyof T]?: never }
+
+export type EmptyObjectOf<T extends object> = EmptyObject<T> extends T ? EmptyObject<T> : never

package/src/IsObjectFactory.ts

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

package/src/JsonObject.ts

@@ -0,0 +1,3 @@
+export type JsonValue = string | number | boolean | null | JsonObject | JsonArray
+export type JsonObject = { [key: string]: JsonValue }
+export type JsonArray = JsonValue[]

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/Override.ts

@@ -0,0 +1,3 @@
+type Override<T1, T2> = Omit<T1, keyof T2> & T2
+
+export type { Override }

package/src/PartialRecord.ts

@@ -0,0 +1,6 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+/** @deprecated use Partial<Record<>> instead */
+export type PartialRecord<K extends keyof any, T> = {
+  [P in K]?: T
+}

package/src/StringKeyObject.ts

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

package/src/Validator.ts

@@ -0,0 +1,13 @@
+import { Promisable } from '@xylabs/promise'
+
+import { AnyObject } from './AnyObject'
+import { EmptyObject } from './EmptyObject'
+import { ObjectWrapper } from './ObjectWrapper'
+
+export interface Validator<T extends EmptyObject = AnyObject> {
+  validate(payload: T): Promisable<Error[]>
+}
+
+export abstract class ValidatorBase<T extends EmptyObject = AnyObject> extends ObjectWrapper<T> implements Validator<T> {
+  abstract validate(payload: T): Promisable<Error[]>
+}

package/src/WithAdditional.ts

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

package/src/asObject.ts

@@ -0,0 +1,5 @@
+import { AnyObject } from './AnyObject'
+import { AsObjectFactory } from './AsObjectFactory'
+import { isObject } from './isObject'
+
+export const asAnyObject = (() => AsObjectFactory.create<AnyObject>(<T extends AnyObject>(obj: unknown): obj is T => isObject(obj)))()

package/src/index.ts

@@ -0,0 +1,16 @@
+export * from './AnyObject'
+export * from './asObject'
+export * from './AsObjectFactory'
+export * from './AsTypeFactory'
+export * from './Base'
+export * from './EmptyObject'
+export * from './isObject'
+export * from './IsObjectFactory'
+export * from './isType'
+export * from './JsonObject'
+export * from './ObjectWrapper'
+export * from './Override'
+export * from './PartialRecord'
+export * from './StringKeyObject'
+export * from './Validator'
+export * from './WithAdditional'

package/src/isObject.ts

@@ -0,0 +1,6 @@
+import { AnyObject } from './AnyObject'
+import { isType } from './isType'
+
+export const isObject = (value: unknown): value is AnyObject => {
+  return isType(value, 'object')
+}

package/src/isType.ts

@@ -0,0 +1,31 @@
+/* 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"
+}