@varlet/use 2.8.6 → 2.8.7-alpha.1678160786574

package/lib/index.d.ts

@@ -1,3 +1,5 @@
 export * from './useEventListener.js';
 export * from './useClickOutside.js';
-export * from './useMounted';
+export * from './useMounted.js';
+export * from './useParent.js';
+export * from './useChildren.js';

package/lib/index.js

@@ -1,3 +1,5 @@
 export * from './useEventListener.js';
 export * from './useClickOutside.js';
-export * from './useMounted';
+export * from './useMounted.js';
+export * from './useParent.js';
+export * from './useChildren.js';

package/lib/useChildren.d.ts

@@ -0,0 +1,11 @@
+import { type ComponentInternalInstance, type ComputedRef } from 'vue';
+export interface UseChildrenBaseProvider<C> {
+    childInstances: ComponentInternalInstance[];
+    collect(instance: ComponentInternalInstance, childProvider: C): void;
+    clear(instance: ComponentInternalInstance, childProvider: C): void;
+}
+export declare function useChildren<P, C>(key: symbol): {
+    length: ComputedRef<number>;
+    childProviders: C[];
+    bindChildren: (parentProvider: P) => void;
+};

package/lib/useChildren.js

@@ -0,0 +1,52 @@
+import { removeItem } from '@varlet/shared';
+import { getCurrentInstance, computed, provide, reactive, isVNode, } from 'vue';
+function flatVNodes(subTree) {
+    const vNodes = [];
+    const flat = (subTree) => {
+        if (subTree === null || subTree === void 0 ? void 0 : subTree.component) {
+            flat(subTree === null || subTree === void 0 ? void 0 : subTree.component.subTree);
+            return;
+        }
+        if (Array.isArray(subTree === null || subTree === void 0 ? void 0 : subTree.children)) {
+            subTree.children.forEach((child) => {
+                if (isVNode(child)) {
+                    vNodes.push(child);
+                    flat(child);
+                }
+            });
+        }
+    };
+    flat(subTree);
+    return vNodes;
+}
+export function useChildren(key) {
+    const parentInstance = getCurrentInstance();
+    const childInstances = reactive([]);
+    const childProviders = [];
+    const length = computed(() => childInstances.length);
+    const sortInstances = () => {
+        const vNodes = flatVNodes(parentInstance.subTree);
+        childInstances.sort((a, b) => {
+            return vNodes.indexOf(a.vnode) - vNodes.indexOf(b.vnode);
+        });
+    };
+    const collect = (childInstance, childProvider) => {
+        childInstances.push(childInstance);
+        childProviders.push(childProvider);
+        sortInstances();
+    };
+    const clear = (childInstance, childProvider) => {
+        removeItem(childInstances, childInstance);
+        removeItem(childProviders, childProvider);
+    };
+    const bindChildren = (parentProvider) => {
+        provide(key, Object.assign({ childInstances,
+            collect,
+            clear }, parentProvider));
+    };
+    return {
+        length,
+        childProviders,
+        bindChildren,
+    };
+}

package/lib/useParent.d.ts

@@ -0,0 +1,12 @@
+import { type ComputedRef } from 'vue';
+import { type UseChildrenBaseProvider } from './useChildren.js';
+export declare function keyInProvides(key: symbol): boolean;
+export declare function useParent<P, C>(key: symbol): {
+    index: null;
+    parentProvider: null;
+    bindParent: null;
+} | {
+    index: ComputedRef<number>;
+    parentProvider: Omit<P & UseChildrenBaseProvider<C>, "childInstances" | "collect" | "clear">;
+    bindParent: (childProvider: C) => void;
+};

package/lib/useParent.js

@@ -0,0 +1,46 @@
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import { getCurrentInstance, inject, onMounted, onBeforeUnmount, nextTick, computed, } from 'vue';
+export function keyInProvides(key) {
+    const instance = getCurrentInstance();
+    return key in instance.provides;
+}
+export function useParent(key) {
+    if (!keyInProvides(key)) {
+        return {
+            index: null,
+            parentProvider: null,
+            bindParent: null,
+        };
+    }
+    const provider = inject(key);
+    const { childInstances, collect, clear } = provider, parentProvider = __rest(provider, ["childInstances", "collect", "clear"]);
+    const childInstance = getCurrentInstance();
+    const index = computed(() => childInstances.indexOf(childInstance));
+    const bindParent = (childProvider) => {
+        onMounted(() => {
+            nextTick().then(() => {
+                collect(childInstance, childProvider);
+            });
+        });
+        onBeforeUnmount(() => {
+            nextTick().then(() => {
+                clear(childInstance, childProvider);
+            });
+        });
+    };
+    return {
+        index,
+        parentProvider,
+        bindParent,
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@varlet/use",
-  "version": "2.8.6",
+  "version": "2.8.7-alpha.1678160786574",
   "type": "module",
   "main": "lib/index.js",
   "module": "lib/index.js",
@@ -24,7 +24,7 @@
     "url": "https://github.com/varletjs/varlet/issues"
   },
   "dependencies": {
-    "@varlet/shared": "2.8.6"
+    "@varlet/shared": "2.8.7-alpha.1678160786574"
   },
   "devDependencies": {
     "typescript": "^4.4.4",