@naturalcycles/js-lib 14.101.0 → 14.104.0

package/src/is.util.ts

@@ -0,0 +1,77 @@
+import { Primitive } from './typeFest'
+import { AnyObject, FalsyValue, NullishValue } from './types'
+
+type Nullish<T> = T extends NullishValue ? T : never
+type Truthy<T> = T extends FalsyValue ? never : T
+type Falsy<T> = T extends FalsyValue ? T : never
+
+export const _isNull = <T>(v: T): v is T extends null ? T : never => v === null
+export const _isUndefined = <T>(v: T): v is T extends undefined ? T : never =>
+  typeof v === 'undefined'
+export const _isNullish = <T>(v: T): v is Nullish<T> => typeof v === 'undefined' || v === null
+export const _isNotNullish = <T>(v: T): v is NonNullable<T> => v !== undefined && v !== null
+
+/**
+ * Same as Boolean, but with correct type output.
+ * Related:
+ * https://github.com/microsoft/TypeScript/issues/16655
+ * https://www.karltarvas.com/2021/03/11/typescript-array-filter-boolean.html
+ *
+ * @example
+ *
+ * [1, 2, undefined].filter(_isTruthy)
+ * // => [1, 2]
+ */
+export const _isTruthy = <T>(v: T): v is Truthy<T> => !!v
+export const _isFalsy = <T>(v: T): v is Falsy<T> => !v
+
+/**
+ * Returns true if item is Object, not null and not Array.
+ */
+export function _isObject(item: any): item is AnyObject {
+  return (typeof item === 'object' && item !== null && !Array.isArray(item)) || false
+}
+
+export function _isPrimitive(v: any): v is Primitive {
+  return (
+    v === null ||
+    v === undefined ||
+    typeof v === 'number' ||
+    typeof v === 'boolean' ||
+    typeof v === 'string' ||
+    typeof v === 'bigint' ||
+    typeof v === 'symbol'
+  )
+}
+
+export function _isEmptyObject(obj: any): boolean {
+  return obj && obj.constructor === Object && Object.keys(obj).length === 0
+}
+
+/**
+ * Object is considered empty if it's one of:
+ * undefined
+ * null
+ * '' (empty string)
+ * [] (empty array)
+ * {} (empty object)
+ * new Map() (empty Map)
+ * new Set() (empty Set)
+ */
+export function _isEmpty(obj: any): boolean {
+  if (obj === undefined || obj === null) return true
+
+  if (typeof obj === 'string' || Array.isArray(obj)) {
+    return obj.length === 0
+  }
+
+  if (obj instanceof Map || obj instanceof Set) {
+    return obj.size === 0
+  }
+
+  if (typeof obj === 'object') {
+    return Object.keys(obj).length === 0
+  }
+
+  return false
+}

package/src/json-schema/jsonSchemaBuilder.ts

@@ -78,6 +78,9 @@ export const jsonSchema = {
   unixTimestamp() {
     return new JsonSchemaNumberBuilder().unixTimestamp()
   },
+  unixTimestamp2000() {
+    return new JsonSchemaNumberBuilder().unixTimestamp2000()
+  },
   // string types
   string() {
     return new JsonSchemaStringBuilder()
@@ -246,7 +249,9 @@ export class JsonSchemaNumberBuilder extends JsonSchemaAnyBuilder<number, JsonSc
   float = () => this.format('float')
   double = () => this.format('double')
   unixTimestamp = () => this.format('unixTimestamp')
+  unixTimestamp2000 = () => this.format('unixTimestamp2000')
   unixTimestampMillis = () => this.format('unixTimestampMillis')
+  unixTimestampMillis2000 = () => this.format('unixTimestampMillis2000')
   utcOffset = () => this.format('utcOffset')
   utcOffsetHours = () => this.format('utcOffsetHours')
 }
@@ -370,8 +375,8 @@ export class JsonSchemaObjectBuilder<T extends AnyObject> extends JsonSchemaAnyB
   ): JsonSchemaObjectBuilder<T & BaseDBEntity<ID>> {
     Object.assign(this.schema.properties, {
       id: { type: idType },
-      created: { type: 'number', format: 'unixTimestamp' },
-      updated: { type: 'number', format: 'unixTimestamp' },
+      created: { type: 'number', format: 'unixTimestamp2000' },
+      updated: { type: 'number', format: 'unixTimestamp2000' },
     })
 
     return this

package/src/json-schema/jsonSchemas.ts

@@ -3,12 +3,12 @@ import { jsonSchema } from './jsonSchemaBuilder'
 
 export const baseDBEntityJsonSchema = jsonSchema.object<BaseDBEntity>({
   id: jsonSchema.string().optional(),
-  created: jsonSchema.unixTimestamp().optional(),
-  updated: jsonSchema.unixTimestamp().optional(),
+  created: jsonSchema.unixTimestamp2000().optional(),
+  updated: jsonSchema.unixTimestamp2000().optional(),
 })
 
 export const savedDBEntityJsonSchema = jsonSchema.object<SavedDBEntity>({
   id: jsonSchema.string(),
-  created: jsonSchema.unixTimestamp(),
-  updated: jsonSchema.unixTimestamp(),
+  created: jsonSchema.unixTimestamp2000(),
+  updated: jsonSchema.unixTimestamp2000(),
 })

package/src/object/object.util.ts

@@ -1,3 +1,4 @@
+import { _isEmpty, _isObject } from '../is.util'
 import { PropertyPath } from '../lodash.types'
 import { AnyObject, ObjectMapper, ObjectPredicate, StringMap, ValueOf } from '../types'
 
@@ -190,55 +191,6 @@ export function _deepCopy<T>(o: T): T {
   return JSON.parse(JSON.stringify(o))
 }
 
-/**
- * Returns true if item is Object, not null and not Array.
- */
-export function _isObject(item: any): item is AnyObject {
-  return (typeof item === 'object' && item !== null && !Array.isArray(item)) || false
-}
-
-export function _isPrimitive(v: any): v is null | undefined | number | boolean | string {
-  return (
-    v === null ||
-    v === undefined ||
-    typeof v === 'number' ||
-    typeof v === 'boolean' ||
-    typeof v === 'string'
-  )
-}
-
-export function _isEmptyObject(obj: any): boolean {
-  return obj && obj.constructor === Object && Object.keys(obj).length === 0
-}
-
-/**
- * Object is considered empty if it's one of:
- * undefined
- * null
- * '' (empty string)
- * [] (empty array)
- * {} (empty object)
- * new Map() (empty Map)
- * new Set() (empty Set)
- */
-export function _isEmpty(obj: any): boolean {
-  if (obj === undefined || obj === null) return true
-
-  if (typeof obj === 'string' || Array.isArray(obj)) {
-    return obj.length === 0
-  }
-
-  if (obj instanceof Map || obj instanceof Set) {
-    return obj.size === 0
-  }
-
-  if (typeof obj === 'object') {
-    return Object.keys(obj).length === 0
-  }
-
-  return false
-}
-
 /**
  * Returns `undefined` if it's empty (according to `_isEmpty()` specification),
  * otherwise returns the original object.

package/src/object/sortObjectDeep.ts

@@ -1,4 +1,4 @@
-import { _isObject } from './object.util'
+import { _isObject } from '..'
 
 /**
  * based on: https://github.com/IndigoUnited/js-deep-sort-object

package/src/types.ts

@@ -260,3 +260,6 @@ export function _stringMapEntries<T>(m: StringMap<T>): [k: string, v: T][] {
 export function _objectKeys<T extends AnyObject>(obj: T): (keyof T)[] {
   return Object.keys(obj)
 }
+
+export type NullishValue = null | undefined
+export type FalsyValue = false | '' | 0 | null | undefined