@v-c/util 0.0.1

package/dist/test/domHook.d.ts

@@ -0,0 +1,8 @@
+export type ElementClass = Function;
+export type Property = PropertyDescriptor | Function;
+export declare function spyElementPrototypes<T extends ElementClass>(elementClass: T, properties: Record<string, Property>): {
+    mockRestore(): void;
+};
+export declare function spyElementPrototype(Element: ElementClass, propName: string, property: Property): {
+    mockRestore(): void;
+};

package/dist/test/domHook.js

@@ -0,0 +1,37 @@
+const y = { __NOT_EXIST: !0 };
+function p(r, n) {
+  const c = Object.keys(n), s = {};
+  return c.forEach((o) => {
+    const t = Object.getOwnPropertyDescriptor(r.prototype, o);
+    s[o] = t || y;
+    const e = n[o];
+    typeof e == "function" ? r.prototype[o] = function(...f) {
+      return e.call(this, t, ...f);
+    } : Object.defineProperty(r.prototype, o, {
+      ...e,
+      set(i) {
+        return e.set ? e.set.call(this, t, i) : t.set(i);
+      },
+      get() {
+        return e.get ? e.get.call(this, t) : t.get();
+      },
+      configurable: !0
+    });
+  }), {
+    mockRestore() {
+      c.forEach((o) => {
+        const t = s[o];
+        t === y ? delete r.prototype[o] : typeof t == "function" ? r.prototype[o] = t : Object.defineProperty(r.prototype, o, t);
+      });
+    }
+  };
+}
+function u(r, n, c) {
+  return p(r, {
+    [n]: c
+  });
+}
+export {
+  u as spyElementPrototype,
+  p as spyElementPrototypes
+};

package/dist/type.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const r=(...e)=>e,o=(...e)=>e;function y(e){const t=e;return t.install=function(n){n.component(t.displayName||t.name,e)},e}function p(){return{type:[Function,Array]}}function a(e){return{type:Object,default:e}}function i(e){return{type:Boolean,default:e}}function c(e){return{type:Function,default:e}}function u(e,t){const n={validator:()=>!0,default:e};return n}function l(){return{validator:()=>!0}}function f(e){return{type:Array,default:e}}function T(e){return{type:String,default:e}}function d(e,t){return e?{type:e,default:t}:u(t)}exports.anyType=u;exports.arrayType=f;exports.booleanType=i;exports.eventType=p;exports.functionType=c;exports.objectType=a;exports.someType=d;exports.stringType=T;exports.tuple=r;exports.tupleNum=o;exports.vNodeType=l;exports.withInstall=y;

package/dist/type.d.ts

@@ -0,0 +1,63 @@
+import { Plugin, PropType, Ref, SlotsType, VNode } from 'vue';
+
+export declare const tuple: <T extends string[]>(...args: T) => T;
+export declare const tupleNum: <T extends number[]>(...args: T) => T;
+/**
+ * https://stackoverflow.com/a/59187769
+ * Extract the type of an element of an array/tuple without performing indexing
+ */
+export type ElementOf<T> = T extends (infer E)[] ? E : T extends readonly (infer F)[] ? F : never;
+/**
+ * https://github.com/Microsoft/TypeScript/issues/29729
+ */
+export type LiteralUnion<T extends string> = T | (string & {});
+export type Data = Record<string, unknown>;
+export type Key = string | number;
+type DefaultFactory<T> = (props: Data) => T | null | undefined;
+export interface PropOptions<T = any, D = T> {
+    type?: PropType<T> | true | null;
+    required?: boolean;
+    default?: D | DefaultFactory<D> | null | undefined | object;
+    validator?: (value: unknown) => boolean;
+}
+declare type VNodeChildAtom = VNode | string | number | boolean | null | undefined | void;
+export type VueNode = VNodeChildAtom | VNodeChildAtom[] | VNode;
+export declare function withInstall<T>(comp: T): T & Plugin;
+export type MaybeRef<T> = T | Ref<T>;
+export declare function eventType<T>(): {
+    type: PropType<T | T[]>;
+};
+export declare function objectType<T = object>(defaultVal?: T): {
+    type: PropType<T>;
+    default: T;
+};
+export declare function booleanType(defaultVal?: boolean): {
+    type: BooleanConstructor;
+    default: boolean;
+};
+export declare function functionType<T = () => object>(defaultVal?: T): {
+    type: PropType<T>;
+    default: T;
+};
+export declare function anyType<T = any>(defaultVal?: T, required?: boolean): {
+    default: T;
+    type: PropType<T>;
+};
+export declare function vNodeType<T = VueNode>(): {
+    type: PropType<T>;
+};
+export declare function arrayType<T extends any[]>(defaultVal?: T): {
+    type: PropType<T>;
+    default: T;
+};
+export declare function stringType<T extends string = string>(defaultVal?: T): {
+    type: PropType<T>;
+    default: T;
+};
+export declare function someType<T>(types?: any[], defaultVal?: T): {
+    type: PropType<T>;
+    default: T;
+};
+export type CustomSlotsType<T extends Record<string, any>> = SlotsType<T>;
+export type AnyObject = Record<PropertyKey, any>;
+export {};

package/dist/type.js

@@ -0,0 +1,49 @@
+const r = (...t) => t, o = (...t) => t;
+function a(t) {
+  const n = t;
+  return n.install = function(e) {
+    e.component(n.displayName || n.name, t);
+  }, t;
+}
+function i() {
+  return { type: [Function, Array] };
+}
+function y(t) {
+  return { type: Object, default: t };
+}
+function c(t) {
+  return { type: Boolean, default: t };
+}
+function p(t) {
+  return { type: Function, default: t };
+}
+function u(t, n) {
+  const e = { validator: () => !0, default: t };
+  return e;
+}
+function f() {
+  return { validator: () => !0 };
+}
+function l(t) {
+  return { type: Array, default: t };
+}
+function d(t) {
+  return { type: String, default: t };
+}
+function T(t, n) {
+  return t ? { type: t, default: n } : u(n);
+}
+export {
+  u as anyType,
+  l as arrayType,
+  c as booleanType,
+  i as eventType,
+  p as functionType,
+  y as objectType,
+  T as someType,
+  d as stringType,
+  r as tuple,
+  o as tupleNum,
+  f as vNodeType,
+  a as withInstall
+};

package/dist/utils/checkSlotProp.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});function n(t,e,u,...i){var c,f;return e[u]?(c=e[u])==null?void 0:c.call(e,...i):u in t?typeof t[u]=="function"?(f=t[u])==null?void 0:f.call(t,...i):t[u]:null}exports.checkSlotProp=n;

package/dist/utils/checkSlotProp.d.ts

@@ -0,0 +1 @@
+export declare function checkSlotProp(props: Record<string, any>, slots: Record<string, any>, name: string, ...args: any[]): any;

package/dist/utils/checkSlotProp.js

@@ -0,0 +1,7 @@
+function e(u, i, f, ...n) {
+  var c, t;
+  return i[f] ? (c = i[f]) == null ? void 0 : c.call(i, ...n) : f in u ? typeof u[f] == "function" ? (t = u[f]) == null ? void 0 : t.call(u, ...n) : u[f] : null;
+}
+export {
+  e as checkSlotProp
+};

package/dist/utils/get.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperties(exports,{__esModule:{value:!0},[Symbol.toStringTag]:{value:"Module"}});function l(u,r){let e=u;for(let t=0;t<r.length;t+=1){if(e==null)return;e=e[r[t]]}return e}exports.default=l;

package/dist/utils/get.d.ts

@@ -0,0 +1 @@
+export default function get(entity: any, path: (string | number | symbol)[] | readonly (string | number | symbol)[]): any;

package/dist/utils/get.js

@@ -0,0 +1,12 @@
+function l(n, r) {
+  let e = n;
+  for (let t = 0; t < r.length; t += 1) {
+    if (e == null)
+      return;
+    e = e[r[t]];
+  }
+  return e;
+}
+export {
+  l as default
+};

package/dist/utils/set.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperties(exports,{__esModule:{value:!0},[Symbol.toStringTag]:{value:"Module"}});const u=require("./get.cjs");function g(e,t,o,l){if(!t.length)return o;const[r,...f]=t;let n;return!e&&typeof r=="number"?n=[]:Array.isArray(e)?n=[...e]:n={...e},l&&o===void 0&&f.length===1?delete n[r][f[0]]:n[r]=g(n[r],f,o,l),n}function i(e,t,o,l=!1){return t.length&&l&&o===void 0&&!u.default(e,t.slice(0,-1))?e:g(e,t,o,l)}function b(e){return typeof e=="object"&&e!==null&&Object.getPrototypeOf(e)===Object.prototype}function y(e){return Array.isArray(e)?[]:{}}const A=typeof Reflect>"u"?Object.keys:Reflect.ownKeys;function O(...e){let t=y(e[0]);return e.forEach(o=>{function l(r,f){const n=new Set(f),c=u.default(o,r),s=Array.isArray(c);if(s||b(c)){if(!n.has(c)){n.add(c);const a=u.default(t,r);s?t=i(t,r,[]):(!a||typeof a!="object")&&(t=i(t,r,y(c))),A(c).forEach(d=>{l([...r,d],n)})}}else t=i(t,r,c)}l([])}),t}exports.default=i;exports.merge=O;

package/dist/utils/set.d.ts

@@ -0,0 +1,6 @@
+export type Path = (string | number | symbol)[];
+export default function set<Entity = any, Output = Entity, Value = any>(entity: Entity, paths: Path, value: Value, removeIfUndefined?: boolean): Output;
+/**
+ * Merge objects which will create
+ */
+export declare function merge<T extends object>(...sources: T[]): T;

package/dist/utils/set.js

@@ -0,0 +1,41 @@
+import s from "./get.js";
+function g(e, r, o, c) {
+  if (!r.length)
+    return o;
+  const [t, ...i] = r;
+  let n;
+  return !e && typeof t == "number" ? n = [] : Array.isArray(e) ? n = [...e] : n = { ...e }, c && o === void 0 && i.length === 1 ? delete n[t][i[0]] : n[t] = g(n[t], i, o, c), n;
+}
+function l(e, r, o, c = !1) {
+  return r.length && c && o === void 0 && !s(e, r.slice(0, -1)) ? e : g(e, r, o, c);
+}
+function b(e) {
+  return typeof e == "object" && e !== null && Object.getPrototypeOf(e) === Object.prototype;
+}
+function a(e) {
+  return Array.isArray(e) ? [] : {};
+}
+const O = typeof Reflect > "u" ? Object.keys : Reflect.ownKeys;
+function j(...e) {
+  let r = a(e[0]);
+  return e.forEach((o) => {
+    function c(t, i) {
+      const n = new Set(i), f = s(o, t), u = Array.isArray(f);
+      if (u || b(f)) {
+        if (!n.has(f)) {
+          n.add(f);
+          const y = s(r, t);
+          u ? r = l(r, t, []) : (!y || typeof y != "object") && (r = l(r, t, a(f))), O(f).forEach((A) => {
+            c([...t, A], n);
+          });
+        }
+      } else
+        r = l(r, t, f);
+    }
+    c([]);
+  }), r;
+}
+export {
+  l as default,
+  j as merge
+};

package/dist/vnode.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const o=require("vue"),f=require("./props-util/index.cjs"),p=require("./warning.cjs");function s(e,r={},t=!0,u=!1){let n=e;if(Array.isArray(e)&&(n=f.filterEmpty(e)[0]),!n)return null;const i=o.cloneVNode(n,r,u);return i.props=t?{...i.props,...r}:i.props,p.warningOnce(typeof i.props.class!="object","class must be string"),i}function a(e,r={},t=!0){return e.map(u=>s(u,r,t))}function c(e,r={},t=!0,u=!1){if(Array.isArray(e))return e.map(n=>c(n,r,t,u));{if(!o.isVNode(e))return e;const n=s(e,r,t,u);return Array.isArray(n.children)&&(n.children=c(n.children)),n}}function d(e,r,t){o.render(o.cloneVNode(e,{...r}),t)}function l(e){return(e||[]).some(r=>o.isVNode(r)?!(r.type===o.Comment||r.type===o.Fragment&&!l(r.children)):!0)?e:null}function m(e,r,t,u){var i;const n=(i=e[r])==null?void 0:i.call(e,t);return l(n)?n:u==null?void 0:u()}exports.cloneElement=s;exports.cloneVNodes=a;exports.customRenderSlot=m;exports.deepCloneElement=c;exports.triggerVNodeUpdate=d;

package/dist/vnode.d.ts

@@ -0,0 +1,12 @@
+import { Slots, VNode, VNodeArrayChildren, VNodeProps } from 'vue';
+import { RefObject } from './createRef';
+
+type NodeProps = Record<string, any> & Omit<VNodeProps, 'ref'> & {
+    ref?: VNodeProps['ref'] | RefObject;
+};
+export declare function cloneElement<T, U>(vnode: VNode<T, U> | VNode<T, U>[], nodeProps?: NodeProps, override?: boolean, mergeRef?: boolean): VNode<T, U> | null;
+export declare function cloneVNodes(vnodes: any, nodeProps?: {}, override?: boolean): any;
+export declare function deepCloneElement<T, U>(vnode: VNode<T, U> | VNode<T, U>[], nodeProps?: NodeProps, override?: boolean, mergeRef?: boolean): any;
+export declare function triggerVNodeUpdate(vm: VNode, attrs: Record<string, any>, dom: any): void;
+export declare function customRenderSlot(slots: Slots, name: string, props: Record<string, unknown>, fallback?: () => VNodeArrayChildren): VNodeArrayChildren | undefined;
+export {};

package/dist/vnode.js

@@ -0,0 +1,41 @@
+import { cloneVNode as f, isVNode as p, render as c, Comment as l, Fragment as a } from "vue";
+import { filterEmpty as y } from "./props-util/index.js";
+import { warningOnce as A } from "./warning.js";
+function m(r, e = {}, n = !0, u = !1) {
+  let t = r;
+  if (Array.isArray(r) && (t = y(r)[0]), !t)
+    return null;
+  const i = f(t, e, u);
+  return i.props = n ? { ...i.props, ...e } : i.props, A(typeof i.props.class != "object", "class must be string"), i;
+}
+function g(r, e = {}, n = !0) {
+  return r.map((u) => m(u, e, n));
+}
+function o(r, e = {}, n = !0, u = !1) {
+  if (Array.isArray(r))
+    return r.map((t) => o(t, e, n, u));
+  {
+    if (!p(r))
+      return r;
+    const t = m(r, e, n, u);
+    return Array.isArray(t.children) && (t.children = o(t.children)), t;
+  }
+}
+function E(r, e, n) {
+  c(f(r, { ...e }), n);
+}
+function s(r) {
+  return (r || []).some((e) => p(e) ? !(e.type === l || e.type === a && !s(e.children)) : !0) ? r : null;
+}
+function C(r, e, n, u) {
+  var i;
+  const t = (i = r[e]) == null ? void 0 : i.call(r, n);
+  return s(t) ? t : u == null ? void 0 : u();
+}
+export {
+  m as cloneElement,
+  g as cloneVNodes,
+  C as customRenderSlot,
+  o as deepCloneElement,
+  E as triggerVNodeUpdate
+};

package/dist/warning.cjs

@@ -0,0 +1 @@
+"use strict";Object.defineProperties(exports,{__esModule:{value:!0},[Symbol.toStringTag]:{value:"Module"}});let i={};const s=[];function u(e){s.push(e)}function l(e,n){if(process.env.NODE_ENV!=="production"&&!e&&console!==void 0){const o=s.reduce((t,c)=>c(t??"","warning"),n);o&&console.error(`Warning: ${o}`)}}function f(e,n){if(process.env.NODE_ENV!=="production"&&!e&&console!==void 0){const o=s.reduce((t,c)=>c(t??"","note"),n);o&&console.warn(`Note: ${o}`)}}function d(){i={}}function a(e,n,o){!n&&!i[o]&&(e(!1,o),i[o]=!0)}function r(e,n){a(l,e,n)}function g(e,n){a(f,e,n)}r.preMessage=u;r.resetWarned=d;r.noteOnce=g;exports.call=a;exports.default=r;exports.note=f;exports.noteOnce=g;exports.preMessage=u;exports.resetWarned=d;exports.warning=l;exports.warningOnce=r;

package/dist/warning.d.ts

@@ -0,0 +1,18 @@
+export type preMessageFn = (message: string, type: 'warning' | 'note') => string | null | undefined | number;
+/**
+ * Pre warning enable you to parse content before console.error.
+ * Modify to null will prevent warning.
+ */
+export declare function preMessage(fn: preMessageFn): void;
+export declare function warning(valid: boolean, message: string): void;
+export declare function note(valid: boolean, message: string): void;
+export declare function resetWarned(): void;
+export declare function call(method: (valid: boolean, message: string) => void, valid: boolean, message: string): void;
+export declare function warningOnce(valid: boolean, message: string): void;
+export declare namespace warningOnce {
+    var preMessage: typeof import("./warning").preMessage;
+    var resetWarned: typeof import("./warning").resetWarned;
+    var noteOnce: typeof import("./warning").noteOnce;
+}
+export declare function noteOnce(valid: boolean, message: string): void;
+export default warningOnce;

package/dist/warning.js

@@ -0,0 +1,48 @@
+let i = {};
+const t = [];
+function f(n) {
+  t.push(n);
+}
+function u(n, e) {
+  if (process.env.NODE_ENV !== "production" && !n && console !== void 0) {
+    const o = t.reduce(
+      (r, c) => c(r ?? "", "warning"),
+      e
+    );
+    o && console.error(`Warning: ${o}`);
+  }
+}
+function l(n, e) {
+  if (process.env.NODE_ENV !== "production" && !n && console !== void 0) {
+    const o = t.reduce(
+      (r, c) => c(r ?? "", "note"),
+      e
+    );
+    o && console.warn(`Note: ${o}`);
+  }
+}
+function d() {
+  i = {};
+}
+function a(n, e, o) {
+  !e && !i[o] && (n(!1, o), i[o] = !0);
+}
+function s(n, e) {
+  a(u, n, e);
+}
+function p(n, e) {
+  a(l, n, e);
+}
+s.preMessage = f;
+s.resetWarned = d;
+s.noteOnce = p;
+export {
+  a as call,
+  s as default,
+  l as note,
+  p as noteOnce,
+  f as preMessage,
+  d as resetWarned,
+  u as warning,
+  s as warningOnce
+};

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "@v-c/util",
+  "type": "module",
+  "version": "0.0.1",
+  "description": "Vue3 components utils",
+  "publishConfig": {
+    "access": "public"
+  },
+  "author": {
+    "name": "aibayanyu20",
+    "email": "aibayanyu@qq.com",
+    "url": "https://yanyu.me"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    },
+    "./dist/*": "./dist/*",
+    "./*": {
+      "types": "./dist/*",
+      "import": "./dist/*",
+      "require": "./dist/*",
+      "default": "./dist/*"
+    },
+    "./package.json": "./package.json"
+  },
+  "main": "dist/index.js",
+  "peerDependencies": {
+    "vue": "^3.0.0"
+  },
+  "scripts": {
+    "build": "vite build",
+    "prepublish": "pnpm build"
+  }
+}

package/src/Children/isFragment.ts

@@ -0,0 +1,6 @@
+import type { VNode, VNodeChild } from 'vue'
+import { Fragment, isVNode } from 'vue'
+
+export function isFragment(node: VNodeChild): node is VNode {
+  return isVNode(node) && node.type === Fragment
+}

package/src/Children/tests/isFragment.test.tsx

@@ -0,0 +1,15 @@
+import { describe, expect, it } from 'vitest'
+import { createVNode } from 'vue'
+import { isFragment } from '@vue-components/util/Children/isFragment.ts'
+
+describe('isFragment', () => {
+  it('should ', () => {
+    const Dom = createVNode('div', null, '1')
+
+    const dom = isFragment(Dom)
+    const dom1 = isFragment(<>1</>)
+
+    expect(dom).toBe(false)
+    expect(dom1).toBe(true)
+  })
+})

package/src/Children/tests/toArray.test.tsx

@@ -0,0 +1,101 @@
+import { describe, expect, it } from 'vitest'
+import { Fragment, defineComponent } from 'vue'
+import { mount } from '@vue/test-utils'
+import { toArray } from '@vue-components/util/Children/toArray.ts'
+
+describe('toArray', () => {
+  let children: any
+  const UL = defineComponent({
+    setup(_, { slots }) {
+      return () => {
+        children = slots.default?.()
+        return <ul>{slots.default?.()}</ul>
+      }
+    },
+  })
+  it('basic', () => {
+    const wrapper = mount(
+      <UL>
+        <li key={1}>1</li>
+        <li key={2}>2</li>
+        <li key={3}>3</li>
+      </UL>,
+    )
+    const nodes = toArray(children)
+    expect(nodes).toHaveLength(3)
+    expect(nodes.map(v => v.key)).toEqual([1, 2, 3])
+    wrapper.unmount()
+  })
+
+  it('array', () => {
+    const wrapper = mount(
+      <UL>
+        <li key={1}>1</li>
+        {[<li key={2}>2</li>, <li key={3}>3</li>]}
+      </UL>,
+    )
+    const nodes = toArray(children)
+    expect(nodes).toHaveLength(3)
+    expect(nodes.map(v => v.key)).toEqual([1, 2, 3])
+    wrapper.unmount()
+  })
+
+  it('fragment', () => {
+    const wrapper = mount(
+      <UL>
+        <li key={1}>1</li>
+        <>
+          <li key="2">2</li>
+          <li key="3">3</li>
+        </>
+        <Fragment>
+          <>
+            <li key="4">4</li>
+            <li key="5">5</li>
+          </>
+        </Fragment>
+      </UL>,
+    )
+    const nodes = toArray(children)
+    expect(nodes).toHaveLength(5)
+    expect(nodes.map(v => v.key)).toEqual([1, '2', '3', '4', '5'])
+    wrapper.unmount()
+  })
+
+  it('keep empty', () => {
+    const wrapper = mount(
+      <UL>
+        {null}
+        <li key="1">1</li>
+        <>
+          <li key="2">2</li>
+          {null}
+          <li key="3">3</li>
+        </>
+        <Fragment>
+          <>
+            <li key="4">4</li>
+            {undefined}
+            <li key="5">5</li>
+          </>
+        </Fragment>
+        {undefined}
+      </UL>,
+    )
+
+    const nodes = toArray(children, { keepEmpty: true })
+    expect(nodes).toHaveLength(9)
+    expect(nodes.map(c => c && c.key)).toEqual([
+      null,
+      '1',
+      '2',
+      null,
+      '3',
+      '4',
+      undefined,
+      '5',
+      null,
+    ])
+    wrapper.unmount()
+  })
+})

package/src/Children/toArray.ts

@@ -0,0 +1,27 @@
+import type { VNode } from 'vue'
+import { isFragment } from './isFragment'
+
+export interface Option {
+  keepEmpty?: boolean
+}
+
+export function toArray(children: any, option: Option = {}) {
+  // 从slots中获取的必定是数组
+  let ret: VNode[] = []
+  // 判断children是否是一个数组，如果不是就把它放到一个数组中
+  if (!Array.isArray(children))
+    children = [children]
+  for (const child of children) {
+    if ((child === undefined || child === null) && !option.keepEmpty)
+      continue
+
+    if (Array.isArray(child))
+      ret = ret.concat(toArray(child, option))
+
+    else if (isFragment(child) && child.children)
+      ret = ret.concat(toArray(child.children, option))
+    else
+      ret.push(child)
+  }
+  return ret
+}

package/src/Dom/addEventListener.ts

@@ -0,0 +1,20 @@
+export type WindowEventName = keyof WindowEventMap
+export type DocumentEventName = keyof DocumentEventMap
+export function addEventListener<E extends WindowEventName = WindowEventName>(target: Window, eventType: E, cb: WindowEventMap[E], option?: AddEventListenerOptions): {
+  remove(): void
+}
+export function addEventListener<E extends DocumentEventName = DocumentEventName>(target: Document, eventType: E, cb: DocumentEventMap[E], option?: AddEventListenerOptions): {
+  remove(): void
+}
+
+export function addEventListener(...args: any[]) {
+  const [target, eventType, cb, option] = args
+  if (target?.addEventListener)
+    target.addEventListener(eventType as any, cb, option)
+
+  return {
+    remove() {
+      target?.removeEventListener?.(eventType as any, cb, option)
+    },
+  }
+}

package/src/Dom/canUseDom.ts

@@ -0,0 +1,7 @@
+export default function canUseDom() {
+  return !!(
+    typeof window !== 'undefined'
+    && window.document
+    && window.document.createElement
+  )
+}

package/src/Dom/class.ts

@@ -0,0 +1,29 @@
+export function hasClass(node: Element, className: string) {
+  if (node.classList)
+    return node.classList.contains(className)
+
+  const originClass = node.className
+  return ` ${originClass} `.includes(` ${className} `)
+}
+
+export function addClass(node: Element, className: string) {
+  if (node.classList) {
+    node.classList.add(className)
+  }
+  else {
+    if (!hasClass(node, className))
+      node.className = `${node.className} ${className}`
+  }
+}
+
+export function removeClass(node: Element, className: string) {
+  if (node.classList) {
+    node.classList.remove(className)
+  }
+  else {
+    if (hasClass(node, className)) {
+      const originClass = node.className
+      node.className = ` ${originClass} `.replace(` ${className} `, ' ')
+    }
+  }
+}

package/src/Dom/contains.ts

@@ -0,0 +1,19 @@
+export default function contains(root: Node | null | undefined, n?: Node) {
+  if (!root)
+    return false
+
+  // Use native if support
+  if (root.contains)
+    return root.contains(n as any)
+
+  // `document.contains` not support with IE11
+  let node: any = n
+  while (node) {
+    if (node === root)
+      return true
+
+    node = node.parentNode
+  }
+
+  return false
+}