@windwalker-io/unicorn-next 0.1.0 → 0.1.2

package/src/composable/useGrid.ts

@@ -1,57 +1,57 @@
-import type { UnicornGridElement } from '../module/grid';
-import { useForm, useFormAsync } from './useForm';
-import { selectOne, module } from '../service';
-
-let gridElement: typeof UnicornGridElement;
-
-export async function useGridAsync(
-  ele?: string | HTMLElement,
-  options: Record<string, any> | undefined = {}
-): Promise<UnicornGridElement | null> {
-  await useFormAsync();
-
-  const { UnicornGridElement } = await import('../module/grid');
-
-  gridElement ??= UnicornGridElement;
-
-  if (!ele) {
-    return null;
-  }
-
-  return useGrid(ele, options);
-}
-
-export function useGrid(
-  ele: string | HTMLElement,
-  options: Record<string, any> | undefined = {}
-): UnicornGridElement | null {
-  const selector = typeof ele === 'string' ? ele : '';
-  const element = selectOne(ele);
-
-  if (!element) {
-    throw new Error('Element is empty');
-  }
-
-  const form = useForm(selector || element);
-
-  if (!form) {
-    throw new Error('UnicornGrid is depends on UnicornForm');
-  }
-
-  return module(
-    element,
-    'grid.plugin',
-    () => new gridElement(selector, element, form, options)
-  );
-}
-
-export async function useGridComponent(
-  ele: string | HTMLElement,
-  options: Record<string, any> | undefined = {}
-): Promise<UnicornGridElement | null> {
-  const grid = await useGridAsync(ele, options);
-
-  await grid?.initComponent();
-
-  return grid;
-}
+import type { UnicornGridElement } from '../module/grid';
+import { useForm, useFormAsync } from './useForm';
+import { selectOne, module } from '../service';
+
+let gridElement: typeof UnicornGridElement;
+
+export async function useGridAsync(
+  ele?: string | HTMLElement,
+  options: Record<string, any> | undefined = {}
+): Promise<UnicornGridElement | null> {
+  await useFormAsync();
+
+  const { UnicornGridElement } = await import('../module/grid');
+
+  gridElement ??= UnicornGridElement;
+
+  if (!ele) {
+    return null;
+  }
+
+  return useGrid(ele, options);
+}
+
+export function useGrid(
+  ele: string | HTMLElement,
+  options: Record<string, any> | undefined = {}
+): UnicornGridElement | null {
+  const selector = typeof ele === 'string' ? ele : '';
+  const element = selectOne(ele);
+
+  if (!element) {
+    throw new Error('Element is empty');
+  }
+
+  const form = useForm(selector || element);
+
+  if (!form) {
+    throw new Error('UnicornGrid is depends on UnicornForm');
+  }
+
+  return module(
+    element,
+    'grid.plugin',
+    () => new gridElement(selector, element, form, options)
+  );
+}
+
+export async function useGridComponent(
+  ele: string | HTMLElement,
+  options: Record<string, any> | undefined = {}
+): Promise<UnicornGridElement | null> {
+  const grid = await useGridAsync(ele, options);
+
+  await grid?.initComponent();
+
+  return grid;
+}

package/src/composable/useHttp.ts

@@ -1,8 +1,9 @@
-import type { UnicornHttpClient } from '../module/http-client';
-import type { AxiosInstance, CreateAxiosDefaults } from 'axios';
-
-export async function useHttpClient(config?: CreateAxiosDefaults | AxiosInstance): Promise<UnicornHttpClient> {
-  const { createHttpClient } = await import('../module/http-client');
-
-  return createHttpClient(config as CreateAxiosDefaults | undefined);
-}
+import type { UnicornHttpClient } from '../module/http-client';
+import type { AxiosInstance, CreateAxiosDefaults } from 'axios';
+export type { ApiReturn, UnicornHttpClient } from '../module/http-client';
+
+export async function useHttpClient(config?: CreateAxiosDefaults | AxiosInstance): Promise<UnicornHttpClient> {
+  const { createHttpClient } = await import('../module/http-client');
+
+  return createHttpClient(config as CreateAxiosDefaults | undefined);
+}

package/src/composable/useIframeModal.ts

@@ -1,9 +1,10 @@
-import { IframeModalModule } from '../module/iframe-modal';
-
-export async function useIframeModal(): Promise<IframeModalModule> {
-  const module = await import('../module/iframe-modal');
-
-  await module.ready;
-
-  return module;
-}
+import { IFrameModalModule } from '../module/iframe-modal';
+export type { IFrameModalElement } from '../module/iframe-modal';
+
+export async function useIframeModal(): Promise<IFrameModalModule> {
+  const module = await import('../module/iframe-modal');
+
+  await module.ready;
+
+  return module;
+}

package/src/composable/useListDependent.ts

@@ -1,26 +1,26 @@
-import type { ListDependent, ListDependentModule, ListDependentOptions } from '../module/list-dependent';
-import { Nullable } from '../types';
-
-export async function useListDependent(): Promise<ListDependentModule>;
-export async function useListDependent(
-  element: string | HTMLSelectElement,
-  dependent?: Nullable<string | HTMLSelectElement>,
-  options?: Partial<ListDependentOptions>
-): Promise<ListDependent>;
-export async function useListDependent(
-  element?: Nullable<string | HTMLSelectElement>,
-  dependent?: Nullable<string | HTMLSelectElement>,
-  options: Partial<ListDependentOptions> = {}
-): Promise<any> {
-  const module = await import('../module/list-dependent');
-
-  await module.ready;
-
-  if (element) {
-    const { ListDependent } = module;
-
-    return ListDependent.handle(element, dependent ?? undefined, options);
-  }
-
-  return module;
-}
+import type { ListDependent, ListDependentModule, ListDependentOptions } from '../module/list-dependent';
+import { Nullable } from '../types';
+
+export async function useListDependent(): Promise<ListDependentModule>;
+export async function useListDependent(
+  element: string | HTMLSelectElement,
+  dependent?: Nullable<string | HTMLSelectElement>,
+  options?: Partial<ListDependentOptions>
+): Promise<ListDependent>;
+export async function useListDependent(
+  element?: Nullable<string | HTMLSelectElement>,
+  dependent?: Nullable<string | HTMLSelectElement>,
+  options: Partial<ListDependentOptions> = {}
+): Promise<any> {
+  const module = await import('../module/list-dependent');
+
+  await module.ready;
+
+  if (element) {
+    const { ListDependent } = module;
+
+    return ListDependent.handle(element, dependent ?? undefined, options);
+  }
+
+  return module;
+}

package/src/composable/useQueue.ts

@@ -1,13 +1,13 @@
-import { Dictionary } from '../types';
-import { TaskQueue, queue } from '@lyrasoft/ts-toolkit/generic';
-
-const queues: Dictionary<TaskQueue> = {};
-
-export function useQueue(name: string = 'default', maxRunning = 1): TaskQueue {
-  return queues[name] ??= createQueue(maxRunning);
-}
-
-export function createQueue(maxRunning = 1): TaskQueue {
-  return queue(maxRunning);
-}
-
+import { Dictionary } from '../types';
+import { TaskQueue, queue } from '@lyrasoft/ts-toolkit/generic';
+
+const queues: Dictionary<TaskQueue> = {};
+
+export function useQueue(name: string = 'default', maxRunning = 1): TaskQueue {
+  return queues[name] ??= createQueue(maxRunning);
+}
+
+export function createQueue(maxRunning = 1): TaskQueue {
+  return queue(maxRunning);
+}
+

package/src/composable/useS3Uploader.ts

@@ -1,32 +1,32 @@
-import {
-  S3MultipartUploader,
-  S3MultipartUploaderModule,
-  S3MultipartUploaderOptions
-} from '../module/s3-multipart-uploader';
-import type { S3Uploader, S3UploaderGlobalOptions, S3UploaderModule } from '../module/s3-uploader';
-
-export async function useS3Uploader(): Promise<S3UploaderModule>;
-export async function useS3Uploader(name: string, options?: Partial<S3UploaderGlobalOptions>): Promise<S3Uploader>;
-export async function useS3Uploader(name?: string, options: Partial<S3UploaderGlobalOptions> = {}): Promise<any> {
-  const module = await import('../module/s3-uploader');
-
-  if (!name) {
-    return module;
-  }
-
-  const { get } = module;
-
-  return get(name, options);
-}
-
-export async function useS3MultipartUploader(): Promise<S3MultipartUploaderModule>;
-export async function useS3MultipartUploader(options: Partial<S3MultipartUploaderOptions>): Promise<S3MultipartUploader>;
-export async function useS3MultipartUploader(options?: Partial<S3MultipartUploaderOptions>): Promise<any> {
-  const module = await import('../module/s3-multipart-uploader');
-
-  if (options != null) {
-    return new module.S3MultipartUploader(options);
-  }
-
-  return module;
-}
+import {
+  S3MultipartUploader,
+  S3MultipartUploaderModule,
+  S3MultipartUploaderOptions
+} from '../module/s3-multipart-uploader';
+import type { S3Uploader, S3UploaderGlobalOptions, S3UploaderModule } from '../module/s3-uploader';
+
+export async function useS3Uploader(): Promise<S3UploaderModule>;
+export async function useS3Uploader(name: string, options?: Partial<S3UploaderGlobalOptions>): Promise<S3Uploader>;
+export async function useS3Uploader(name?: string, options: Partial<S3UploaderGlobalOptions> = {}): Promise<any> {
+  const module = await import('../module/s3-uploader');
+
+  if (!name) {
+    return module;
+  }
+
+  const { get } = module;
+
+  return get(name, options);
+}
+
+export async function useS3MultipartUploader(): Promise<S3MultipartUploaderModule>;
+export async function useS3MultipartUploader(options: Partial<S3MultipartUploaderOptions>): Promise<S3MultipartUploader>;
+export async function useS3MultipartUploader(options?: Partial<S3MultipartUploaderOptions>): Promise<any> {
+  const module = await import('../module/s3-multipart-uploader');
+
+  if (options != null) {
+    return new module.S3MultipartUploader(options);
+  }
+
+  return module;
+}

package/src/composable/useShowOn.ts

@@ -1,9 +1,9 @@
-import { ShowOnModule } from '../module/show-on';
-
-export async function useShowOn(): Promise<ShowOnModule> {
-  const module = await import('../module/show-on');
-
-  await module.ready;
-
-  return module;
-}
+import { ShowOnModule } from '../module/show-on';
+
+export async function useShowOn(): Promise<ShowOnModule> {
+  const module = await import('../module/show-on');
+
+  await module.ready;
+
+  return module;
+}

package/src/composable/useStack.ts

@@ -1,13 +1,13 @@
-
-import { Dictionary } from '../types';
-import { Stack, stack } from '@lyrasoft/ts-toolkit/generic';
-
-const stacks: Dictionary<Stack> = {};
-
-export function useStack<T = any>(name: string = 'default', store: any[] = []): Stack<T> {
-  return stacks[name] ??= createStack<T>(store);
-}
-
-export function createStack<T = any>(store: any[] = []): Stack<T> {
-  return stack<T>(store);
-}
+
+import { Dictionary } from '../types';
+import { Stack, stack } from '@lyrasoft/ts-toolkit/generic';
+
+const stacks: Dictionary<Stack> = {};
+
+export function useStack<T = any>(name: string = 'default', store: any[] = []): Stack<T> {
+  return stacks[name] ??= createStack<T>(store);
+}
+
+export function createStack<T = any>(store: any[] = []): Stack<T> {
+  return stack<T>(store);
+}

package/src/composable/useTinymce.ts

@@ -1,29 +1,29 @@
-import type { TinymceController, TinymceModule } from '../module/tinymce';
-import type { MaybePromise } from '../types';
-import type { TinyMCE } from 'tinymce';
-
-export async function useTinymce(): Promise<TinymceModule>
-export async function useTinymce(
-  selector?: string,
-  options?: Record<string, any>
-): Promise<TinymceController>;
-export async function useTinymce(
-  selector?: string,
-  options: Record<string, any> = {}
-): Promise<any> {
-  const module = await import('../module/tinymce');
-
-  if (selector) {
-    return module.get(selector, options);
-  }
-
-  return module;
-}
-
-export async function useTinymceHook(
-  handler: ((tinymce: TinyMCE) => MaybePromise<any>)
-): Promise<void> {
-  const { addHook } = await import('../module/tinymce');
-
-  return addHook(handler);
-}
+import type { TinymceController, TinymceModule } from '../module/tinymce';
+import type { MaybePromise } from '../types';
+import type { TinyMCE } from 'tinymce';
+
+export async function useTinymce(): Promise<TinymceModule>
+export async function useTinymce(
+  selector?: string,
+  options?: Record<string, any>
+): Promise<TinymceController>;
+export async function useTinymce(
+  selector?: string,
+  options: Record<string, any> = {}
+): Promise<any> {
+  const module = await import('../module/tinymce');
+
+  if (selector) {
+    return module.get(selector, options);
+  }
+
+  return module;
+}
+
+export async function useTinymceHook(
+  handler: ((tinymce: TinyMCE) => MaybePromise<any>)
+): Promise<void> {
+  const { addHook } = await import('../module/tinymce');
+
+  return addHook(handler);
+}

package/src/composable/useTomSelect.ts

@@ -1,72 +1,72 @@
-import { module, useCssImport, useCssIncludes, useImport, wait } from '../service';
-import type { Nullable } from '../types';
-import { mergeDeep } from '../utilities';
-
-/**
- * @see https://tom-select.js.org/
- */
-export async function useTomSelect(
-  selector?: Nullable<string | HTMLElement | NodeListOf<HTMLElement>>,
-  options: Record<string, any> = {},
-  theme: string = 'bootstrap5'
-) {
-  const [m] = await wait(
-    useImport('@vendor/tom-select/dist/js/tom-select.complete.min.js'),
-    useCssImport(`@vendor/tom-select/dist/css/tom-select.${theme}.min.css`)
-  );
-
-  if (selector) {
-    module<any, HTMLSelectElement>(
-      selector,
-      'tom.select',
-      (ele) => {
-        options = mergeDeep({
-          allowEmptyOption: true,
-          maxOptions: null,
-          plugins: {
-            caret_position: {},
-            clear_button: {},
-          }
-        }, options);
-
-        if ((ele as HTMLSelectElement).multiple) {
-          options.plugins.remove_button = {};
-        } else {
-          options.plugins.dropdown_input = {};
-        }
-
-        // Auto select first if options changed.
-        // @see https://github.com/orchidjs/tom-select/issues/362
-        class UnicornTomSelect extends TomSelect {
-          syncOptionsWithoutKeepSelected() {
-            const oldValue = ele.value;
-
-            this.clear();
-            this.clearOptions();
-            this.sync();
-
-            if (ele.value !== oldValue) {
-              this.setValue(
-                ele.querySelector<HTMLOptionElement>(`option[value="${oldValue}"]`)?.value
-                ?? ele.querySelector<HTMLOptionElement>('option')?.value
-                ?? '',
-                true
-              );
-            }
-          }
-        }
-
-        // @ts-ignore
-        const t = new UnicornTomSelect(ele as TomInput, options);
-
-        ele.addEventListener('list:updated', () => {
-          t.syncOptionsWithoutKeepSelected();
-        });
-
-        return t;
-      }
-    );
-  }
-
-  return m;
-}
+import { module, useCssImport, useCssIncludes, useImport, wait } from '../service';
+import type { Nullable } from '../types';
+import { mergeDeep } from '../utilities';
+
+/**
+ * @see https://tom-select.js.org/
+ */
+export async function useTomSelect(
+  selector?: Nullable<string | HTMLElement | NodeListOf<HTMLElement>>,
+  options: Record<string, any> = {},
+  theme: string = 'bootstrap5'
+) {
+  const [m] = await wait(
+    useImport('@vendor/tom-select/dist/js/tom-select.complete.min.js'),
+    useCssImport(`@vendor/tom-select/dist/css/tom-select.${theme}.min.css`)
+  );
+
+  if (selector) {
+    module<any, HTMLSelectElement>(
+      selector,
+      'tom.select',
+      (ele) => {
+        options = mergeDeep({
+          allowEmptyOption: true,
+          maxOptions: null,
+          plugins: {
+            caret_position: {},
+            clear_button: {},
+          }
+        }, options);
+
+        if ((ele as HTMLSelectElement).multiple) {
+          options.plugins.remove_button = {};
+        } else {
+          options.plugins.dropdown_input = {};
+        }
+
+        // Auto select first if options changed.
+        // @see https://github.com/orchidjs/tom-select/issues/362
+        class UnicornTomSelect extends TomSelect {
+          syncOptionsWithoutKeepSelected() {
+            const oldValue = ele.value;
+
+            this.clear();
+            this.clearOptions();
+            this.sync();
+
+            if (ele.value !== oldValue) {
+              this.setValue(
+                ele.querySelector<HTMLOptionElement>(`option[value="${oldValue}"]`)?.value
+                ?? ele.querySelector<HTMLOptionElement>('option')?.value
+                ?? '',
+                true
+              );
+            }
+          }
+        }
+
+        // @ts-ignore
+        const t = new UnicornTomSelect(ele as TomInput, options);
+
+        ele.addEventListener('list:updated', () => {
+          t.syncOptionsWithoutKeepSelected();
+        });
+
+        return t;
+      }
+    );
+  }
+
+  return m;
+}

package/src/composable/useUIBootstrap5.ts

@@ -1,48 +1,48 @@
-import type { Tooltip } from 'bootstrap';
-import { ButtonRadioOptions } from '../bootstrap/button-radio';
-import type { KeepTabOptions } from '../bootstrap/keep-tab';
-import type { UIBootstrap5 } from '../module/ui-bootstrap5';
-import { useUITheme } from '../service';
-
-export async function useUIBootstrap5(install = false, pushToGlobal = false): Promise<UIBootstrap5> {
-  const { UIBootstrap5 } = await import('../module/ui-bootstrap5');
-
-  const theme = UIBootstrap5.get();
-
-  if (install) {
-    useUITheme(theme);
-
-    if (pushToGlobal) {
-      theme.pushBootstrapToGlobal();
-    }
-  }
-
-  return theme;
-}
-
-export async function useBs5Tooltip(
-  selector: NodeListOf<Element> | Element | string = '[data-bs-toggle="tooltip"]',
-  config: Partial<Tooltip.Options> = {}
-): Promise<Tooltip[]> {
-  const bs5 = await useUIBootstrap5();
-
-  return bs5.tooltip(selector, config);
-}
-
-export const useBs5KeepTab: typeof UIBootstrap5.prototype.keepTab = async (
-  selector?: string | HTMLElement,
-  options: KeepTabOptions = {}
-): Promise<any> => {
-  const bs5 = await useUIBootstrap5();
-
-  return bs5.keepTab(selector, options);
-};
-
-export const useBs5ButtonRadio: typeof UIBootstrap5.prototype.buttonRadio = async (
-  selector?: string | HTMLElement,
-  options: ButtonRadioOptions = {}
-): Promise<any> => {
-  const bs5 = await useUIBootstrap5();
-
-  return bs5.buttonRadio(selector, options);
-};
+import type { Tooltip } from 'bootstrap';
+import { ButtonRadioOptions } from '../bootstrap/button-radio';
+import type { KeepTabOptions } from '../bootstrap/keep-tab';
+import type { UIBootstrap5 } from '../module/ui-bootstrap5';
+import { useUITheme } from '../service';
+
+export async function useUIBootstrap5(install = false, pushToGlobal = false): Promise<UIBootstrap5> {
+  const { UIBootstrap5 } = await import('../module/ui-bootstrap5');
+
+  const theme = UIBootstrap5.get();
+
+  if (install) {
+    useUITheme(theme);
+
+    if (pushToGlobal) {
+      theme.pushBootstrapToGlobal();
+    }
+  }
+
+  return theme;
+}
+
+export async function useBs5Tooltip(
+  selector: NodeListOf<Element> | Element | string = '[data-bs-toggle="tooltip"]',
+  config: Partial<Tooltip.Options> = {}
+): Promise<Tooltip[]> {
+  const bs5 = await useUIBootstrap5();
+
+  return bs5.tooltip(selector, config);
+}
+
+export const useBs5KeepTab: typeof UIBootstrap5.prototype.keepTab = async (
+  selector?: string | HTMLElement,
+  options: KeepTabOptions = {}
+): Promise<any> => {
+  const bs5 = await useUIBootstrap5();
+
+  return bs5.keepTab(selector, options);
+};
+
+export const useBs5ButtonRadio: typeof UIBootstrap5.prototype.buttonRadio = async (
+  selector?: string | HTMLElement,
+  options: ButtonRadioOptions = {}
+): Promise<any> => {
+  const bs5 = await useUIBootstrap5();
+
+  return bs5.buttonRadio(selector, options);
+};