@windwalker-io/unicorn-next 0.1.2 → 0.1.4

package/src/composable/useUniDirective.ts

@@ -1,32 +1,32 @@
-import { Dictionary } from '../types';
-import type { default as WebDirective } from 'web-directive';
-import type { WebDirectiveHandler, WebDirectiveOptions } from 'web-directive/src/types';
-
-let instances: Dictionary<WebDirective> = {};
-
-export async function useWebDirective(
-  name: string = 'unicorn',
-  options: Partial<WebDirectiveOptions> = {}
-): Promise<WebDirective> {
-  return instances[name] ??= await createWebDirective(Object.assign({}, options, { prefix: 'uni-' }));
-}
-
-export async function useUniDirective<T extends Element = HTMLElement>(
-  name: string,
-  handler: WebDirectiveHandler<T>,
-  wdInstance: WebDirective | string = 'unicorn'
-): Promise<void> {
-  const wd = typeof wdInstance === 'string' ? await useWebDirective(wdInstance) : wdInstance;
-
-  // Todo: Should fix web-directive types
-  wd.register(name, handler as WebDirectiveHandler<any>);
-}
-
-async function createWebDirective(options: Partial<WebDirectiveOptions> = {}): Promise<WebDirective> {
-  const WebDirective = (await import('web-directive')).default;
-
-  const wd = new WebDirective(options);
-  wd.listen();
-
-  return wd;
-}
+import { Dictionary } from '../types';
+import type { default as WebDirective } from 'web-directive';
+import type { WebDirectiveHandler, WebDirectiveOptions } from 'web-directive/src/types';
+
+let instances: Dictionary<WebDirective> = {};
+
+export async function useWebDirective(
+  name: string = 'unicorn',
+  options: Partial<WebDirectiveOptions> = {}
+): Promise<WebDirective> {
+  return instances[name] ??= await createWebDirective(Object.assign({}, options, { prefix: 'uni-' }));
+}
+
+export async function useUniDirective<T extends Element = HTMLElement>(
+  name: string,
+  handler: WebDirectiveHandler<T>,
+  wdInstance: WebDirective | string = 'unicorn'
+): Promise<void> {
+  const wd = typeof wdInstance === 'string' ? await useWebDirective(wdInstance) : wdInstance;
+
+  // Todo: Should fix web-directive types
+  wd.register(name, handler as WebDirectiveHandler<any>);
+}
+
+async function createWebDirective(options: Partial<WebDirectiveOptions> = {}): Promise<WebDirective> {
+  const WebDirective = (await import('web-directive')).default;
+
+  const wd = new WebDirective(options);
+  wd.listen();
+
+  return wd;
+}

package/src/composable/useValidation.ts

@@ -1,39 +1,39 @@
-import type {
-  UnicornFieldValidation,
-  UnicornFormValidation,
-  ValidationHandler,
-  ValidationModule
-} from '../module/validation';
-import { getBoundedInstance } from '../service';
-
-export async function useFormValidation(): Promise<ValidationModule>;
-export async function useFormValidation(selector: string | Element): Promise<UnicornFormValidation | null>;
-export async function useFormValidation(selector?: string | Element): Promise<any> {
-  const module = await import('../module/validation');
-
-  await module.ready;
-
-  if (!selector) {
-    return module;
-  }
-
-  return useFormValidationInstance(selector);
-}
-
-export function useFormValidationInstance(selector: string | Element): UnicornFormValidation | null {
-  return getBoundedInstance<UnicornFormValidation>(selector, 'form.validation');
-}
-
-export function useFieldValidationSync(selector: string | Element): UnicornFieldValidation | null {
-  return getBoundedInstance<UnicornFieldValidation>(selector, 'field.validation');
-}
-
-export async function addGlobalValidator(
-  name: string,
-  validator: ValidationHandler,
-  options: Record<string, any> = {}
-): Promise<void> {
-  const { UnicornFormValidation } = await useFormValidation();
-
-  UnicornFormValidation.addGlobalValidator(name, validator, options);
-}
+import type {
+  UnicornFieldValidation,
+  UnicornFormValidation,
+  ValidationHandler,
+  ValidationModule
+} from '../module/validation';
+import { getBoundedInstance } from '../service';
+
+export async function useFormValidation(): Promise<ValidationModule>;
+export async function useFormValidation(selector: string | Element): Promise<UnicornFormValidation | null>;
+export async function useFormValidation(selector?: string | Element): Promise<any> {
+  const module = await import('../module/validation');
+
+  await module.ready;
+
+  if (!selector) {
+    return module;
+  }
+
+  return useFormValidationInstance(selector);
+}
+
+export function useFormValidationInstance(selector: string | Element): UnicornFormValidation | null {
+  return getBoundedInstance<UnicornFormValidation>(selector, 'form.validation');
+}
+
+export function useFieldValidationSync(selector: string | Element): UnicornFieldValidation | null {
+  return getBoundedInstance<UnicornFieldValidation>(selector, 'field.validation');
+}
+
+export async function addGlobalValidator(
+  name: string,
+  validator: ValidationHandler,
+  options: Record<string, any> = {}
+): Promise<void> {
+  const { UnicornFormValidation } = await useFormValidation();
+
+  UnicornFormValidation.addGlobalValidator(name, validator, options);
+}

package/src/data.ts

@@ -1,34 +1,34 @@
-import { getData, removeData as rmdata, setData } from './utilities';
-
-export function data(name: string, data?: any): any;
-export function data<T = void, R = [T] extends [void] ? any : T | undefined>(name: string): R;
-export function data<T = void, R = [T] extends [void] ? any : T | undefined>(ele: Element, name: string): R;
-export function data(ele: Element, name: string, value: any): any;
-export function data(ele: Element | string, name?: any, value?: any) {
-  if (!(ele instanceof HTMLElement)) {
-    value = name;
-    name = ele;
-    ele = document as any as Element;
-  }
-
-  if (name === undefined) {
-    return getData(ele);
-  }
-
-  if (value === undefined) {
-    return getData(ele, name);
-  }
-
-  setData(ele, name, value);
-}
-
-export function removeData(name: string): any;
-export function removeData(ele: Element, name: string): any;
-export function removeData(ele: Element|string, name: any = undefined) {
-  if (!(ele instanceof HTMLElement)) {
-    name = ele;
-    ele = document as any as Element;
-  }
-
-  rmdata(ele, name);
-}
+import { getData, removeData as rmdata, setData } from './utilities';
+
+export function data(name: string, data?: any): any;
+export function data<T = void, R = [T] extends [void] ? any : T | undefined>(name: string): R;
+export function data<T = void, R = [T] extends [void] ? any : T | undefined>(ele: Element, name: string): R;
+export function data(ele: Element, name: string, value: any): any;
+export function data(ele: Element | string, name?: any, value?: any) {
+  if (!(ele instanceof HTMLElement)) {
+    value = name;
+    name = ele;
+    ele = document as any as Element;
+  }
+
+  if (name === undefined) {
+    return getData(ele);
+  }
+
+  if (value === undefined) {
+    return getData(ele, name);
+  }
+
+  setData(ele, name, value);
+}
+
+export function removeData(name: string): any;
+export function removeData(ele: Element, name: string): any;
+export function removeData(ele: Element|string, name: any = undefined) {
+  if (!(ele instanceof HTMLElement)) {
+    name = ele;
+    ele = document as any as Element;
+  }
+
+  rmdata(ele, name);
+}

package/src/events.ts

@@ -1,82 +1,82 @@
-export abstract class EventMixin implements EventAwareInterface {
-  _listeners: Record<string, EventHandler[]> = {};
-
-  on<T extends any[]>(event: string, handler: EventHandler<T>): this;
-  on(event: string | string[], handler: EventHandler): this;
-  on(event: string | string[], handler: EventHandler): this {
-    if (Array.isArray(event)) {
-      for (const e of event) {
-        this.on(e, handler);
-      }
-      return this;
-    }
-
-    this._listeners[event] ??= [];
-
-    this._listeners[event].push(handler);
-
-    return this;
-  }
-
-  once<T extends any[]>(event: string, handler: EventHandler<T>): this;
-  once(event: string | string[], handler: EventHandler): this;
-  once(event: string | string[], handler: EventHandler): this {
-    handler.once = true;
-    return this.on(event, handler);
-  }
-
-  off(event: string, handler?: EventHandler): this {
-    if (handler) {
-      this._listeners[event] = this.listeners(event).filter((listener) => listener !== handler);
-      return this;
-    }
-
-    delete this._listeners[event];
-
-    return this;
-  }
-
-  trigger<T extends any[]>(event: string, ...args: T): this;
-  trigger(event: string[], ...args: any[]): this;
-  trigger(event: string | string[], ...args: any[]): this {
-    if (Array.isArray(event)) {
-      for (const e of event) {
-        this.trigger(e);
-      }
-      return this;
-    }
-
-    for (const listener of this.listeners(event)) {
-      listener(...args);
-    }
-
-    // Remove once
-    this._listeners[event] = this.listeners(event).filter((listener) => listener?.once !== true);
-
-    return this;
-  }
-
-  listeners(event: string): EventHandler[] {
-    return this._listeners[event] === undefined ? [] : this._listeners[event];
-  }
-}
-
-// export class EventBus extends Mixin(EventMixin) {
-// }
-
-export type EventHandler<T extends any[] = any[]> = ((...event: T) => void) & { once?: boolean };
-
-export interface EventAwareInterface {
-  on<T extends any[]>(event: string, handler: EventHandler<T>): this;
-  on(event: string | string[], handler: EventHandler): this;
-
-  once<T extends any[]>(event: string, handler: EventHandler<T>): this;
-  once(event: string | string[], handler: EventHandler): this;
-
-  off(event: string, handler?: EventHandler): this;
-
-  trigger<T extends any[]>(event: string, ...args: T): this;
-  trigger(event: string[], ...args: any[]): this;
-
-  listeners(event: string): EventHandler[];
-}
+export abstract class EventMixin implements EventAwareInterface {
+  _listeners: Record<string, EventHandler[]> = {};
+
+  on<T extends any[]>(event: string, handler: EventHandler<T>): this;
+  on(event: string | string[], handler: EventHandler): this;
+  on(event: string | string[], handler: EventHandler): this {
+    if (Array.isArray(event)) {
+      for (const e of event) {
+        this.on(e, handler);
+      }
+      return this;
+    }
+
+    this._listeners[event] ??= [];
+
+    this._listeners[event].push(handler);
+
+    return this;
+  }
+
+  once<T extends any[]>(event: string, handler: EventHandler<T>): this;
+  once(event: string | string[], handler: EventHandler): this;
+  once(event: string | string[], handler: EventHandler): this {
+    handler.once = true;
+    return this.on(event, handler);
+  }
+
+  off(event: string, handler?: EventHandler): this {
+    if (handler) {
+      this._listeners[event] = this.listeners(event).filter((listener) => listener !== handler);
+      return this;
+    }
+
+    delete this._listeners[event];
+
+    return this;
+  }
+
+  trigger<T extends any[]>(event: string, ...args: T): this;
+  trigger(event: string[], ...args: any[]): this;
+  trigger(event: string | string[], ...args: any[]): this {
+    if (Array.isArray(event)) {
+      for (const e of event) {
+        this.trigger(e);
+      }
+      return this;
+    }
+
+    for (const listener of this.listeners(event)) {
+      listener(...args);
+    }
+
+    // Remove once
+    this._listeners[event] = this.listeners(event).filter((listener) => listener?.once !== true);
+
+    return this;
+  }
+
+  listeners(event: string): EventHandler[] {
+    return this._listeners[event] === undefined ? [] : this._listeners[event];
+  }
+}
+
+// export class EventBus extends Mixin(EventMixin) {
+// }
+
+export type EventHandler<T extends any[] = any[]> = ((...event: T) => void) & { once?: boolean };
+
+export interface EventAwareInterface {
+  on<T extends any[]>(event: string, handler: EventHandler<T>): this;
+  on(event: string | string[], handler: EventHandler): this;
+
+  once<T extends any[]>(event: string, handler: EventHandler<T>): this;
+  once(event: string | string[], handler: EventHandler): this;
+
+  off(event: string, handler?: EventHandler): this;
+
+  trigger<T extends any[]>(event: string, ...args: T): this;
+  trigger(event: string[], ...args: any[]): this;
+
+  listeners(event: string): EventHandler[];
+}