@expressive/mvc 1.0.0-beta.38 → 1.0.0-beta.40

package/lib/index.d.ts

@@ -445,8 +445,15 @@ declare class MVC extends Model {
     static new<T extends Class>(this: T, callback?: (instance: InstanceOf<T>) => void): InstanceOf<T>;
     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

@@ -1130,20 +1130,24 @@ class MVC extends Model {
     static new(callback) {
         return useModel(this, [], callback);
     }
-    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);