@naturalcycles/js-lib 14.54.0 → 14.57.0

package/dist-esm/lazy.js

@@ -0,0 +1,50 @@
+/**
+ * const value = lazyValue(() => expensiveComputation())
+ *
+ * value() // calls expensiveComputation() once
+ * value() // returns cached result
+ * value() // returns cached result
+ *
+ * Based on: https://github.com/sindresorhus/lazy-value
+ */
+export function _lazyValue(fn) {
+    let isCalled = false;
+    let result;
+    return (() => {
+        if (!isCalled) {
+            isCalled = true;
+            result = fn();
+        }
+        return result;
+    });
+}
+/**
+ * interface Obj {
+ *   v: number
+ * }
+ *
+ * const obj = {} as Obj
+ *
+ * _defineLazyProperty(obj, 'v', () => expensiveComputation())
+ * obj.v // runs expensiveComputation() once
+ * obj.v // cached value
+ * obj.v // cached value
+ *
+ * Based on: https://github.com/sindresorhus/define-lazy-prop
+ */
+export function _defineLazyProperty(obj, propertyName, fn) {
+    const define = (value) => Object.defineProperty(obj, propertyName, { value, enumerable: true, writable: true });
+    Object.defineProperty(obj, propertyName, {
+        configurable: true,
+        enumerable: true,
+        get() {
+            const result = fn();
+            define(result);
+            return result;
+        },
+        set(value) {
+            define(value);
+        },
+    });
+    return obj;
+}

package/dist-esm/promise/AggregatedError.js

@@ -17,8 +17,6 @@ export class AggregatedError extends Error {
         super(message);
         this.errors = mappedErrors;
         this.results = results;
-        this.constructor = AggregatedError;
-        this.__proto__ = AggregatedError.prototype;
         Object.defineProperty(this, 'name', {
             value: this.constructor.name,
             configurable: true,
@@ -29,6 +27,7 @@ export class AggregatedError extends Error {
         else {
             Object.defineProperty(this, 'stack', {
                 value: new Error().stack,
+                writable: true,
                 configurable: true,
             });
         }

package/dist-esm/string/url.util.js

@@ -0,0 +1,26 @@
+/**
+ * Parses `location.search` string (e.g `?a=1&b=2`) into a StringMap, e.g:
+ * `{ a: '1', b: '2' }`
+ *
+ * Pass `location.search` to it in the Frontend, or any other string on the Backend (where `location.search` is not available).
+ *
+ * Works both with and without leading `?` character.
+ *
+ * Yes, there's `URLSearchParams` existing in the Frontend (not in Node yet), but it's API is not
+ * as convenient. And the implementation here is super-small.
+ *
+ * Goal of this function is to produce exactly same output as URLSearchParams would.
+ */
+export function _parseQueryString(search) {
+    const qs = {};
+    search
+        .substr(search[0] === '?' ? 1 : 0)
+        .split('&')
+        .forEach(p => {
+        const [k, v] = p.split('=');
+        if (!k)
+            return;
+        qs[decodeURIComponent(k)] = decodeURIComponent(v || '');
+    });
+    return qs;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@naturalcycles/js-lib",
-  "version": "14.54.0",
+  "version": "14.57.0",
   "scripts": {
     "prepare": "husky install",
     "build-prod": "build-prod-esm-cjs",
@@ -11,11 +11,10 @@
     "tslib": "^2.0.0"
   },
   "devDependencies": {
+    "@naturalcycles/bench-lib": "^1.5.0",
     "@naturalcycles/dev-lib": "^12.0.0",
     "@naturalcycles/nodejs-lib": "^12.33.4",
-    "@types/benchmark": "^2.1.0",
     "@types/node": "^16.0.0",
-    "benchmark": "^2.1.4",
     "jest": "^27.0.1",
     "patch-package": "^6.2.1",
     "prettier": "^2.1.2",

package/src/error/app.error.ts

@@ -10,21 +10,29 @@ import { ErrorData } from './error.model'
  * Based on: https://medium.com/@xpl/javascript-deriving-from-error-properly-8d2f8f315801
  */
 export class AppError<DATA_TYPE extends ErrorData = ErrorData> extends Error {
-  constructor(message: string, public data = {} as DATA_TYPE) {
+  data!: DATA_TYPE
+
+  constructor(message: string, data = {} as DATA_TYPE) {
     super(message)
 
-    this.constructor = AppError
-    ;(this as any).__proto__ = AppError.prototype
     Object.defineProperty(this, 'name', {
       value: this.constructor.name,
       configurable: true,
     })
 
+    Object.defineProperty(this, 'data', {
+      value: data,
+      writable: true,
+      configurable: true,
+      enumerable: false,
+    })
+
     if (Error.captureStackTrace) {
       Error.captureStackTrace(this, this.constructor)
     } else {
       Object.defineProperty(this, 'stack', {
         value: new Error().stack, // eslint-disable-line unicorn/error-message
+        writable: true,
         configurable: true,
       })
     }

package/src/error/assert.ts

@@ -123,23 +123,7 @@ export function _assertTypeOf<T>(v: any, expectedType: string, message?: string)
 }
 
 export class AssertionError extends AppError {
-  constructor(message: string, data: ErrorData) {
+  constructor(message: string, data = {} as ErrorData) {
     super(message, data)
-
-    this.constructor = AssertionError
-    ;(this as any).__proto__ = AssertionError.prototype
-    Object.defineProperty(this, 'name', {
-      value: this.constructor.name,
-      configurable: true, // otherwise throws with "TypeError: Cannot redefine property: name"
-    })
-
-    if (Error.captureStackTrace) {
-      Error.captureStackTrace(this, this.constructor)
-    } else {
-      Object.defineProperty(this, 'stack', {
-        value: new Error().stack, // eslint-disable-line unicorn/error-message
-        configurable: true,
-      })
-    }
   }
 }

package/src/error/http.error.ts

@@ -9,21 +9,5 @@ export class HttpError<
 > extends AppError<DATA_TYPE> {
   constructor(message: string, data: DATA_TYPE) {
     super(message, data)
-
-    this.constructor = HttpError
-    ;(this as any).__proto__ = HttpError.prototype
-    Object.defineProperty(this, 'name', {
-      value: this.constructor.name,
-      configurable: true, // otherwise throws with "TypeError: Cannot redefine property: name"
-    })
-
-    if (Error.captureStackTrace) {
-      Error.captureStackTrace(this, this.constructor)
-    } else {
-      Object.defineProperty(this, 'stack', {
-        value: new Error().stack, // eslint-disable-line unicorn/error-message
-        configurable: true,
-      })
-    }
   }
 }

package/src/index.ts

@@ -21,6 +21,8 @@ import {
   _uniq,
   _uniqBy,
 } from './array/array.util'
+import { _defineLazyProperty, _lazyValue } from './lazy'
+import { _parseQueryString } from './string/url.util'
 import { _range } from './array/range'
 import {
   PromiseDecoratorCfg,
@@ -447,4 +449,7 @@ export {
   JsonSchemaAnyBuilder,
   JSON_SCHEMA_ORDER,
   generateJsonSchemaFromData,
+  _parseQueryString,
+  _defineLazyProperty,
+  _lazyValue,
 }

package/src/json-schema/from-data/generateJsonSchemaFromData.ts

@@ -10,6 +10,7 @@ import {
   StringMap,
   _stringMapEntries,
   _uniq,
+  AnyObject,
 } from '../..'
 
 type PrimitiveType = 'undefined' | 'null' | 'boolean' | 'string' | 'number'
@@ -20,11 +21,11 @@ type Type = PrimitiveType | 'array' | 'object'
  *
  * `additionalProperties` is set to `true`, cause it's safer.
  */
-export function generateJsonSchemaFromData<T = unknown>(rows: any[]): JsonSchemaObject<T> {
+export function generateJsonSchemaFromData<T = unknown>(rows: AnyObject[]): JsonSchemaObject<T> {
   return objectToJsonSchema(rows as any) as JsonSchemaObject<T>
 }
 
-function objectToJsonSchema(rows: Record<string, any>[]): JsonSchemaObject {
+function objectToJsonSchema(rows: AnyObject[]): JsonSchemaObject {
   const typesByKey: StringMap<Set<Type>> = {}
 
   rows.forEach(r => {

package/src/json-schema/jsonSchema.model.ts

@@ -1,4 +1,4 @@
-import { StringMap } from '../types'
+import { AnyObject, StringMap } from '../types'
 
 // eslint-disable-next-line unused-imports/no-unused-vars
 export type JsonSchema<T = unknown> =
@@ -124,13 +124,11 @@ export interface JsonSchemaRef<T = unknown> extends JsonSchemaAny<T> {
   $ref: string
 }
 
-export interface JsonSchemaRootObject<T extends Record<any, any> = Record<any, unknown>>
-  extends JsonSchemaObject<T> {
+export interface JsonSchemaRootObject<T extends AnyObject = AnyObject> extends JsonSchemaObject<T> {
   $id: string
 }
 
-export interface JsonSchemaObject<T extends Record<any, any> = Record<any, unknown>>
-  extends JsonSchemaAny<T> {
+export interface JsonSchemaObject<T extends AnyObject = AnyObject> extends JsonSchemaAny<T> {
   type: 'object'
   // let's be strict and require all these
   properties: {

package/src/json-schema/jsonSchemaBuilder.ts

@@ -9,6 +9,7 @@ import {
   SavedDBEntity,
   _deepCopy,
   _sortObject,
+  AnyObject,
 } from '../index'
 import { JSON_SCHEMA_ORDER } from './jsonSchema.cnst'
 import {
@@ -86,12 +87,12 @@ export const jsonSchema = {
   },
   // email: () => new JsonSchemaStringBuilder().email(),
   // complex types
-  object<T extends Record<any, any>>(props: {
+  object<T extends AnyObject>(props: {
     [k in keyof T]: JsonSchemaAnyBuilder<T[k]>
   }) {
     return new JsonSchemaObjectBuilder<T>().addProperties(props)
   },
-  rootObject<T extends Record<any, any>>(props: {
+  rootObject<T extends AnyObject>(props: {
     [k in keyof T]: JsonSchemaAnyBuilder<T[k]>
   }) {
     return new JsonSchemaObjectBuilder<T>().addProperties(props).$schemaDraft7()
@@ -309,7 +310,7 @@ export class JsonSchemaStringBuilder extends JsonSchemaAnyBuilder<string, JsonSc
   // contentEncoding?: string
 }
 
-export class JsonSchemaObjectBuilder<T extends Record<any, any>> extends JsonSchemaAnyBuilder<
+export class JsonSchemaObjectBuilder<T extends AnyObject> extends JsonSchemaAnyBuilder<
   T,
   JsonSchemaObject<T>
 > {
@@ -378,9 +379,7 @@ export class JsonSchemaObjectBuilder<T extends Record<any, any>> extends JsonSch
     return this.baseDBEntity().addRequired(['id', 'created', 'updated']) as any
   }
 
-  extend<T2 extends Record<any, any>>(
-    s2: JsonSchemaObjectBuilder<T2>,
-  ): JsonSchemaObjectBuilder<T & T2> {
+  extend<T2 extends AnyObject>(s2: JsonSchemaObjectBuilder<T2>): JsonSchemaObjectBuilder<T & T2> {
     const builder = new JsonSchemaObjectBuilder<T & T2>()
     Object.assign(builder.schema, _deepCopy(this.schema))
     mergeJsonSchemaObjects(builder.schema, s2.schema)

package/src/lazy.ts

@@ -0,0 +1,62 @@
+import { AnyFunction, AnyObject } from './types'
+
+/**
+ * const value = lazyValue(() => expensiveComputation())
+ *
+ * value() // calls expensiveComputation() once
+ * value() // returns cached result
+ * value() // returns cached result
+ *
+ * Based on: https://github.com/sindresorhus/lazy-value
+ */
+export function _lazyValue<T extends AnyFunction>(fn: T): T {
+  let isCalled = false
+  let result: any
+
+  return (() => {
+    if (!isCalled) {
+      isCalled = true
+      result = fn()
+    }
+
+    return result
+  }) as any
+}
+
+/**
+ * interface Obj {
+ *   v: number
+ * }
+ *
+ * const obj = {} as Obj
+ *
+ * _defineLazyProperty(obj, 'v', () => expensiveComputation())
+ * obj.v // runs expensiveComputation() once
+ * obj.v // cached value
+ * obj.v // cached value
+ *
+ * Based on: https://github.com/sindresorhus/define-lazy-prop
+ */
+export function _defineLazyProperty<OBJ extends AnyObject>(
+  obj: OBJ,
+  propertyName: keyof OBJ,
+  fn: AnyFunction,
+): OBJ {
+  const define = (value: any) =>
+    Object.defineProperty(obj, propertyName, { value, enumerable: true, writable: true })
+
+  Object.defineProperty(obj, propertyName, {
+    configurable: true,
+    enumerable: true,
+    get() {
+      const result = fn()
+      define(result)
+      return result
+    },
+    set(value) {
+      define(value)
+    },
+  })
+
+  return obj
+}

package/src/object/object.util.ts

@@ -1,11 +1,11 @@
 import { PropertyPath } from '../lodash.types'
-import { ObjectMapper, ObjectPredicate, StringMap, ValueOf } from '../types'
+import { AnyObject, ObjectMapper, ObjectPredicate, StringMap, ValueOf } from '../types'
 
 /**
  * Returns clone of `obj` with only `props` preserved.
  * Opposite of Omit.
  */
-export function _pick<T extends Record<string, any>, K extends keyof T>(
+export function _pick<T extends AnyObject, K extends keyof T>(
   obj: T,
   props: readonly K[],
   mutate = false,
@@ -29,7 +29,7 @@ export function _pick<T extends Record<string, any>, K extends keyof T>(
  * Returns clone of `obj` with `props` omitted.
  * Opposite of Pick.
  */
-export function _omit<T extends Record<string, any>, K extends keyof T>(
+export function _omit<T extends AnyObject, K extends keyof T>(
   obj: T,
   props: readonly K[],
   mutate = false,
@@ -51,7 +51,7 @@ export function _omit<T extends Record<string, any>, K extends keyof T>(
  *  'account.updated',
  * ])
  */
-export function _mask<T extends Record<string, any>>(obj: T, props: string[], mutate = false): T {
+export function _mask<T extends AnyObject>(obj: T, props: string[], mutate = false): T {
   return props.reduce(
     (r, prop) => {
       _unset(r, prop)
@@ -64,14 +64,14 @@ export function _mask<T extends Record<string, any>>(obj: T, props: string[], mu
 /**
  * Removes "falsy" values from the object.
  */
-export function _filterFalsyValues<T extends Record<string, any>>(obj: T, mutate = false): T {
+export function _filterFalsyValues<T extends AnyObject>(obj: T, mutate = false): T {
   return _filterObject(obj, (_k, v) => !!v, mutate)
 }
 
 /**
  * Removes values from the object that are `null` or `undefined`.
  */
-export function _filterNullishValues<T extends Record<string, any>>(obj: T, mutate = false): T {
+export function _filterNullishValues<T extends AnyObject>(obj: T, mutate = false): T {
   return _filterObject(obj, (_k, v) => v !== undefined && v !== null, mutate)
 }
 
@@ -79,11 +79,11 @@ export function _filterNullishValues<T extends Record<string, any>>(obj: T, muta
  * Removes values from the object that are `undefined`.
  * Only `undefined` values are removed. `null` values are kept!
  */
-export function _filterUndefinedValues<T extends Record<string, any>>(obj: T, mutate = false): T {
+export function _filterUndefinedValues<T extends AnyObject>(obj: T, mutate = false): T {
   return _filterObject(obj, (_k, v) => v !== undefined, mutate)
 }
 
-export function _filterEmptyArrays<T extends Record<string, any>>(obj: T, mutate = false): T {
+export function _filterEmptyArrays<T extends AnyObject>(obj: T, mutate = false): T {
   return _filterObject(obj, (_k, v) => !Array.isArray(v) || v.length > 0, mutate)
 }
 
@@ -91,7 +91,7 @@ export function _filterEmptyArrays<T extends Record<string, any>>(obj: T, mutate
  * Returns clone of `obj` without properties that does not pass `predicate`.
  * Allows filtering by both key and value.
  */
-export function _filterObject<T extends Record<string, any>>(
+export function _filterObject<T extends AnyObject>(
   obj: T,
   predicate: ObjectPredicate<T>,
   mutate = false,
@@ -118,7 +118,7 @@ export function _filterObject<T extends Record<string, any>>(
  * _.mapValues(users, 'age')
  * // => { 'fred': 40, 'pebbles': 1 } (iteration order is not guaranteed)
  */
-export function _mapValues<T extends Record<string, any>, OUT = T>(
+export function _mapValues<T extends AnyObject, OUT = T>(
   obj: T,
   mapper: ObjectMapper<T, any>,
   mutate = false,
@@ -135,7 +135,7 @@ export function _mapValues<T extends Record<string, any>, OUT = T>(
  *
  * Does not support `mutate` flag.
  */
-export function _mapKeys<T extends Record<string, any>>(
+export function _mapKeys<T extends AnyObject>(
   obj: T,
   mapper: ObjectMapper<T, string>,
 ): StringMap<T[keyof T]> {
@@ -162,7 +162,7 @@ export function _mapKeys<T extends Record<string, any>>(
  *
  * Non-string keys are passed via String(...)
  */
-export function _mapObject<IN extends Record<string, any>, OUT>(
+export function _mapObject<IN extends AnyObject, OUT>(
   obj: IN,
   mapper: ObjectMapper<IN, [key: string, value: any]>,
 ): { [P in keyof IN]: OUT } {
@@ -175,17 +175,11 @@ export function _mapObject<IN extends Record<string, any>, OUT>(
   }, {} as { [P in keyof IN]: OUT })
 }
 
-export function _findKeyByValue<T extends Record<any, any>>(
-  obj: T,
-  v: ValueOf<T>,
-): keyof T | undefined {
+export function _findKeyByValue<T extends AnyObject>(obj: T, v: ValueOf<T>): keyof T | undefined {
   return Object.entries(obj).find(([_, value]) => value === v)?.[0] as keyof T
 }
 
-export function _objectNullValuesToUndefined<T extends Record<string, any>>(
-  obj: T,
-  mutate = false,
-): T {
+export function _objectNullValuesToUndefined<T extends AnyObject>(obj: T, mutate = false): T {
   return _mapValues(obj, (_k, v) => (v === null ? undefined : v), mutate)
 }
 
@@ -199,7 +193,7 @@ export function _deepCopy<T>(o: T): T {
 /**
  * Returns true if item is Object, not null and not Array.
  */
-export function _isObject(item: any): item is Record<string, any> {
+export function _isObject(item: any): item is AnyObject {
   return (typeof item === 'object' && item !== null && !Array.isArray(item)) || false
 }
 
@@ -256,7 +250,7 @@ export function _undefinedIfEmpty<T>(obj: T | undefined): T | undefined {
 /**
  * Filters the object by removing all key-value pairs where Value is Empty (according to _isEmpty() specification).
  */
-export function _filterEmptyValues<T extends Record<string, any>>(obj: T, mutate = false): T {
+export function _filterEmptyValues<T extends AnyObject>(obj: T, mutate = false): T {
   return _filterObject(obj, (_k, v) => !_isEmpty(v), mutate)
 }
 
@@ -289,7 +283,7 @@ export function _filterEmptyValues<T extends Record<string, any>>(obj: T, mutate
  *
  * Based on: https://gist.github.com/Salakar/1d7137de9cb8b704e48a
  */
-export function _merge<T extends Record<string, any>>(target: T, ...sources: any[]): T {
+export function _merge<T extends AnyObject>(target: T, ...sources: any[]): T {
   sources.forEach(source => {
     if (_isObject(source)) {
       Object.keys(source).forEach(key => {
@@ -311,7 +305,7 @@ export function _merge<T extends Record<string, any>>(target: T, ...sources: any
  * Doesn't touch object KEYS.
  * Mutates.
  */
-export function _deepTrim<T extends Record<string, any> | string>(o: T): T {
+export function _deepTrim<T extends AnyObject | string>(o: T): T {
   if (!o) return o
 
   if (typeof o === 'string') {
@@ -327,7 +321,7 @@ export function _deepTrim<T extends Record<string, any> | string>(o: T): T {
 
 // from: https://github.com/jonschlinkert/unset-value
 // mutates obj
-export function _unset<T extends Record<string, any>>(obj: T, prop: string): void {
+export function _unset<T extends AnyObject>(obj: T, prop: string): void {
   if (!_isObject(obj)) {
     return
   }
@@ -350,9 +344,7 @@ export function _unset<T extends Record<string, any>>(obj: T, prop: string): voi
   delete obj[last!]
 }
 
-export function _invert<T extends Record<any, any>>(
-  o: T,
-): { [k in ValueOf<T>]: keyof T | undefined } {
+export function _invert<T extends AnyObject>(o: T): { [k in ValueOf<T>]: keyof T | undefined } {
   const inv = {} as { [k in ValueOf<T>]: keyof T }
   Object.keys(o).forEach(k => {
     inv[o[k]] = k
@@ -375,7 +367,7 @@ export function _invertMap<K, V>(m: ReadonlyMap<K, V>): Map<V, K> {
  * @param def The value returned if the resolved value is undefined.
  * @return Returns the resolved value.
  */
-export function _get<T extends Record<string, any>>(obj = {} as T, path = '', def?: any): any {
+export function _get<T extends AnyObject>(obj = {} as T, path = '', def?: any): any {
   const res = path
     .replace(/\[([^\]]+)]/g, '.$1')
     .split('.')
@@ -396,7 +388,7 @@ export function _get<T extends Record<string, any>>(obj = {} as T, path = '', de
  *
  * Based on: https://stackoverflow.com/a/54733755/4919972
  */
-export function _set<IN extends Record<string, any>, OUT = IN>(
+export function _set<IN extends AnyObject, OUT = IN>(
   obj: IN,
   path: PropertyPath,
   value?: any,
@@ -455,7 +447,7 @@ export function _set<IN extends Record<string, any>, OUT = IN>(
  * _.has(other, 'a');
  * // => false
  */
-export function _has<T extends Record<string, any>>(obj: T, path?: string): boolean {
+export function _has<T extends AnyObject>(obj: T, path?: string): boolean {
   const v = _get(obj, path)
   return v !== undefined && v !== null
 }

package/src/object/sortObject.ts

@@ -1,11 +1,11 @@
-import { _omit } from '../index'
+import { _omit, AnyObject } from '../index'
 
 /**
  * Returns new object with keys sorder in the given order.
  * All keys that are not listed in `keyOrder` go last.
  * Does not mutate original object.
  */
-export function _sortObject<T extends Record<any, any>>(obj: T, keyOrder: (keyof T)[]): T {
+export function _sortObject<T extends AnyObject>(obj: T, keyOrder: (keyof T)[]): T {
   const r = {} as T
 
   keyOrder.forEach(key => {

package/src/promise/AggregatedError.ts

@@ -23,8 +23,6 @@ export class AggregatedError<RESULT = any> extends Error {
     this.errors = mappedErrors
     this.results = results
 
-    this.constructor = AggregatedError
-    ;(this as any).__proto__ = AggregatedError.prototype
     Object.defineProperty(this, 'name', {
       value: this.constructor.name,
       configurable: true,
@@ -35,6 +33,7 @@ export class AggregatedError<RESULT = any> extends Error {
     } else {
       Object.defineProperty(this, 'stack', {
         value: new Error().stack, // eslint-disable-line unicorn/error-message
+        writable: true,
         configurable: true,
       })
     }

package/src/string/url.util.ts

@@ -0,0 +1,27 @@
+import { StringMap } from '../types'
+
+/**
+ * Parses `location.search` string (e.g `?a=1&b=2`) into a StringMap, e.g:
+ * `{ a: '1', b: '2' }`
+ *
+ * Pass `location.search` to it in the Frontend, or any other string on the Backend (where `location.search` is not available).
+ *
+ * Works both with and without leading `?` character.
+ *
+ * Yes, there's `URLSearchParams` existing in the Frontend (not in Node yet), but it's API is not
+ * as convenient. And the implementation here is super-small.
+ *
+ * Goal of this function is to produce exactly same output as URLSearchParams would.
+ */
+export function _parseQueryString(search: string): StringMap {
+  const qs = {}
+  search
+    .substr(search[0] === '?' ? 1 : 0)
+    .split('&')
+    .forEach(p => {
+      const [k, v] = p.split('=')
+      if (!k) return
+      qs[decodeURIComponent(k)] = decodeURIComponent(v || '')
+    })
+  return qs
+}

package/src/types.ts

@@ -191,6 +191,6 @@ export function _stringMapEntries<T>(m: StringMap<T>): [k: string, v: T][] {
  *
  * @experimental
  */
-export function _objectKeys<T extends Record<string, any>>(obj: T): (keyof T)[] {
+export function _objectKeys<T extends AnyObject>(obj: T): (keyof T)[] {
   return Object.keys(obj)
 }