@creejs/commons-lang 1.0.7 → 1.0.8

package/lib/class-proxy-utils.js

@@ -0,0 +1,66 @@
+'use strict'
+
+const { isPlainObject } = require('./type-utils')
+
+/**
+ * @module ClassProxyUtils
+ */
+
+/**
+ * Creates a Proxy Class for given class.
+ * @template {object} T
+ * @param {Function} cls - The class to proxycls - The class to proxy
+ * @param {ProxyHandler<T>} [propertyHandler = {}] - Proxy Property Handler
+ * @param {boolean} [sealed=true] - Whether to seal the instance
+ * @returns {Function} A proxied classA proxied instance of the class
+ */
+function proxy (cls, propertyHandler, sealed = true) {
+  if (typeof cls !== 'function') {
+    throw new TypeError(`Not Class: type=${typeof cls}, value=${JSON.stringify(cls)}`)
+  }
+  if (propertyHandler != null) {
+    if (!isPlainObject(propertyHandler)) {
+      throw new TypeError(`Not PropertyHandler: type=${typeof propertyHandler}, value=${JSON.stringify(propertyHandler)}`)
+    }
+    const { get, set } = propertyHandler
+    if (get != null && typeof get !== 'function') {
+      throw new TypeError(`Not PropertyHandler.get: type=${typeof get}, value=${JSON.stringify(get)}`)
+    }
+    if (set != null && typeof set !== 'function') {
+      throw new TypeError(`Not PropertyHandler.set: type=${typeof set}, value=${JSON.stringify(set)}`)
+    }
+  }
+  const construcHandler = {
+    /**
+     * Creates a proxied instance of a class, optionally sealing it.
+     * @param {Function} constructor - The class constructor to instantiate.
+     * @param {any[]} args - Arguments to pass to the constructor.
+     * @param {Function} [newTarget] - The constructor that was originally called by `new`.
+     * @returns {Proxy} A proxied instance of the constructed class.
+     */
+    construct (constructor, args, newTarget) {
+      const clsInstance = Reflect.construct(constructor, args)
+      return new Proxy(sealed ? Object.preventExtensions(clsInstance) : clsInstance, propertyHandler ?? {})
+    }
+  }
+  return new Proxy(cls, construcHandler)
+}
+
+/**
+ * Creates a proxied instance of a class with custom property handling.
+ * @template {object} T
+ * @param {Function} cls - The class to proxy
+ * @param {any[]} args - Arguments to pass to the constructor
+ * @param {ProxyHandler<T>} propertyHandler - Handler for property access/mutation
+ * @param {boolean} [sealed=true] - Whether the proxy should be sealed
+ * @returns {T} Proxied class instance
+ */
+function newProxyInstance (cls, args, propertyHandler, sealed = true) {
+  const proxyCls = proxy(cls, propertyHandler, sealed)
+  return Reflect.construct(proxyCls, args ?? [])
+}
+
+module.exports = {
+  proxy,
+  newProxyInstance
+}

package/lib/index.js

@@ -11,6 +11,8 @@ const TypeUtils = require('./type-utils')
 const TypeAssert = require('./type-assert')
 const ExecUtils = require('./exec-utils')
 const PromiseUtils = require('./promise-utils')
+const ClassProxyUtils = require('./class-proxy-utils')
+const InstanceProxyUtils = require('./instance-proxy-utils')
 
 module.exports = {
   LangUtils,
@@ -22,5 +24,7 @@ module.exports = {
   Lang: LangUtils,
   String: StringUtils,
   Type: TypeUtils,
-  Exec: ExecUtils
-}
+  Exec: ExecUtils,
+  ClassProxyUtils,
+  InstanceProxyUtils
+}

package/lib/instance-proxy-utils.js

@@ -0,0 +1,27 @@
+'use strict'
+
+const { isObject, isNil, isArray } = require('./type-utils')
+
+/**
+ * @module InstanceProxyUtils
+ */
+
+/**
+ * Creates a proxy wrapper around an object instance with optional property handler.
+ * @template {object} T
+ * @param {T} instance - The target object to proxy
+ * @param {ProxyHandler<T>} [propertyHandler] - Optional proxy handler for property access
+ * @param {boolean} [sealed=true] - Whether to prevent extensions on the target object
+ * @returns {T} The proxied object instance
+ * @throws {TypeError} If instance is not an object
+ */
+function proxy (instance, propertyHandler, sealed = true) {
+  if (isNil(instance) || !isObject(instance) || isArray(instance)) {
+    throw new TypeError(`Not Object: type=${typeof instance}, value=${JSON.stringify(instance)}`)
+  }
+  return new Proxy(sealed ? Object.preventExtensions(instance) : instance, propertyHandler ?? {})
+}
+
+module.exports = {
+  proxy
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@creejs/commons-lang",
-  "version": "1.0.7",
+  "version": "1.0.8",
   "description": "Commons Utils About Language",
   "main": "index.js",
   "private": false,

package/types/class-proxy-utils.d.ts

@@ -0,0 +1,22 @@
+/**
+ * @module ClassProxyUtils
+ */
+/**
+ * Creates a Proxy Class for given class.
+ * @template {object} T
+ * @param {Function} cls - The class to proxycls - The class to proxy
+ * @param {ProxyHandler<T>} [propertyHandler = {}] - Proxy Property Handler
+ * @param {boolean} [sealed=true] - Whether to seal the instance
+ * @returns {Function} A proxied classA proxied instance of the class
+ */
+export function proxy<T extends object>(cls: Function, propertyHandler?: ProxyHandler<T>, sealed?: boolean): Function;
+/**
+ * Creates a proxied instance of a class with custom property handling.
+ * @template {object} T
+ * @param {Function} cls - The class to proxy
+ * @param {any[]} args - Arguments to pass to the constructor
+ * @param {ProxyHandler<T>} propertyHandler - Handler for property access/mutation
+ * @param {boolean} [sealed=true] - Whether the proxy should be sealed
+ * @returns {T} Proxied class instance
+ */
+export function newProxyInstance<T extends object>(cls: Function, args: any[], propertyHandler: ProxyHandler<T>, sealed?: boolean): T;

package/types/index.d.ts

@@ -4,4 +4,6 @@ import TypeUtils = require("./type-utils");
 import TypeAssert = require("./type-assert");
 import ExecUtils = require("./exec-utils");
 import PromiseUtils = require("./promise-utils");
-export { LangUtils, StringUtils, TypeUtils, TypeAssert, ExecUtils, PromiseUtils, LangUtils as Lang, StringUtils as String, TypeUtils as Type, ExecUtils as Exec };
+import ClassProxyUtils = require("./class-proxy-utils");
+import InstanceProxyUtils = require("./instance-proxy-utils");
+export { LangUtils, StringUtils, TypeUtils, TypeAssert, ExecUtils, PromiseUtils, LangUtils as Lang, StringUtils as String, TypeUtils as Type, ExecUtils as Exec, ClassProxyUtils, InstanceProxyUtils };

package/types/instance-proxy-utils.d.ts

@@ -0,0 +1,13 @@
+/**
+ * @module InstanceProxyUtils
+ */
+/**
+ * Creates a proxy wrapper around an object instance with optional property handler.
+ * @template {object} T
+ * @param {T} instance - The target object to proxy
+ * @param {ProxyHandler<T>} [propertyHandler] - Optional proxy handler for property access
+ * @param {boolean} [sealed=true] - Whether to prevent extensions on the target object
+ * @returns {T} The proxied object instance
+ * @throws {TypeError} If instance is not an object
+ */
+export function proxy<T extends object>(instance: T, propertyHandler?: ProxyHandler<T>, sealed?: boolean): T;