@expressive/mvc 1.0.0-beta.39 → 1.0.0-beta.41

package/lib/index.d.ts

@@ -442,11 +442,19 @@ declare class MVC extends Model {
      *
      * @param callback - Run after creation of instance.
      */
-    static new<T extends Class>(this: T, callback?: (instance: InstanceOf<T>) => void): InstanceOf<T>;
+    static new<T extends Class, I extends InstanceOf<T>>(this: T, callback?: (instance: I) => void): I;
+    static new<T extends Class, I extends InstanceOf<T>>(this: T, apply: Model.Compat<I>): I;
     static use<T extends Class, I extends InstanceOf<T>>(this: T, watch: Model.Field<I>[], callback?: (instance: I) => void): I;
     static use<T extends Class, I extends InstanceOf<T>>(this: T, callback?: (instance: I) => void): I;
-    static uses<T extends typeof MVC, I extends InstanceOf<T>, D extends Partial<I>>(this: T, data: D, only?: (keyof D & string)[]): InstanceOf<T>;
-    static using<T extends typeof MVC, I extends InstanceOf<T>, D extends Partial<I>>(this: T, data: D, only?: (keyof D & string)[]): InstanceOf<T>;
+    static use<T extends Class, I extends InstanceOf<T>>(this: T, apply: Model.Compat<I>, keys?: Model.Event<I>[]): I;
+    /**
+     * @deprecated consider doing this manually - not worth minor efficiency gain over using.
+    */
+    static uses<T extends typeof MVC, I extends InstanceOf<T>, D extends Model.Compat<I>>(this: T, apply: D, keys?: (keyof D)[]): InstanceOf<T>;
+    /**
+     * @deprecated is now replaced by overload of `use` method.
+    */
+    static using<T extends typeof MVC, I extends InstanceOf<T>>(this: T, apply: Model.Compat<I>, keys?: Model.Event<I>[]): I;
     static meta<T extends Class>(this: T): T;
     static meta<T extends Class, K extends keyof T>(this: T, key: K, expect: true): Exclude<T[K], undefined>;
     static meta<T extends Class, K extends keyof T>(this: T, key: K, expect?: boolean): T[K];

package/lib/index.esm.js

@@ -1120,30 +1120,38 @@ class MVC extends Model {
     static tap(key, expect) {
         return useTap(this, key, expect);
     }
-    /**
-     * **React Hook** - Spawn and maintain a controller from within a component.
-     *
-     * More efficient than `use()` if you don't need hook-based features.
-     *
-     * @param callback - Run after creation of instance.
-     */
-    static new(callback) {
-        return useModel(this, [], callback);
+    static new(arg) {
+        return React.useMemo(() => {
+            const instance = new this();
+            control(instance);
+            if (typeof arg == "function")
+                arg(instance);
+            else if (arg)
+                getOwnPropertyNames(instance).forEach(key => {
+                    if (key in arg)
+                        instance[key] = arg[key];
+                });
+            return instance;
+        }, []);
     }
-    static use(arg, callback) {
-        const instance = useModel(this, arg, callback);
+    static use(a, b) {
+        const instance = useModel(this, a, b);
         usePeerContext(instance.get);
         return instance;
     }
-    static uses(data, only) {
+    /**
+     * @deprecated consider doing this manually - not worth minor efficiency gain over using.
+    */
+    static uses(apply, keys) {
         return this.use(instance => {
-            instance.import(data, only);
+            instance.import(apply, keys);
         });
     }
-    static using(data, only) {
-        const instance = this.use();
-        instance.import(data, only);
-        return instance;
+    /**
+     * @deprecated is now replaced by overload of `use` method.
+    */
+    static using(apply, keys) {
+        return this.use(apply, keys);
     }
     static meta(path, expect) {
         return useTap(() => this, path, expect);