@windwalker-io/unicorn-next 0.1.7 → 0.1.9

package/src/service/index.ts

@@ -1,10 +1,10 @@
-export * from './animate';
-export * from './crypto';
-export * from './dom';
-export * from './dom-watcher';
-export * from './helper';
-export * from './lang';
-export * from './loader';
-export * from './ui';
-export * from './uri';
-export * from './router';
+export * from './animate';
+export * from './crypto';
+export * from './dom';
+export * from './dom-watcher';
+export * from './helper';
+export * from './lang';
+export * from './loader';
+export * from './ui';
+export * from './uri';
+export * from './router';

package/src/service/lang.ts

@@ -1,122 +1,122 @@
-import { data } from '../data';
-import { isDebug } from './/helper';
-import { Dictionary } from '../types';
-import { vsprintf } from 'sprintf-js';
-
-let lang: UnicornLang;
-
-export function useLang() {
-  return lang ??= new UnicornLang();
-}
-
-export function trans(id: string, ...args: any[]) {
-  return useLang().trans(id, ...args);
-}
-
-export function __(id: string, ...args: any[]) {
-  return trans(id, ...args);
-}
-
-export default class UnicornLang {
-  /**
-   * Translate a string.
-   */
-  trans(id: string, ...args: any[]): string {
-    const key = this.normalize(id);
-
-    let translated = this.get(key) || '';
-
-    translated = this.replace(translated, args);
-
-    return translated !== '' ? translated : this.wrapDebug(id, false);
-  }
-
-  protected replace(str: string, args: any[]): string {
-    let replacements: Dictionary<any> = {};
-    let values: any[] = [];
-
-    for (const arg of args) {
-      if (typeof arg === 'object') {
-        replacements = { ...replacements, ...arg };
-      } else {
-        values.push(arg);
-      }
-    }
-
-    if (values.length) {
-      str = vsprintf(str, values);
-    }
-
-    if (Object.values(replacements).length) {
-      for (const key in replacements) {
-        let value = replacements[key];
-
-        if (typeof value === 'function') {
-          value = value();
-        }
-
-        str = str.replace(new RegExp(':' + key, 'g'), String(value));
-      }
-    }
-
-    return str;
-  }
-
-  /**
-   * Find text.
-   */
-  get(id: string): string | null {
-    const strings = this.getStrings();
-
-    if (strings[id]) {
-      return strings[id];
-    }
-
-    return null;
-  }
-
-  /**
-   * Has language key.
-   */
-  has(key: string): boolean {
-    const strings = this.getStrings();
-
-    return strings[key] !== undefined;
-  }
-
-  /**
-   * Add language key.
-   */
-  add(key: string, value: string): this {
-    const strings = this.getStrings();
-
-    strings[this.normalize(key)] = value;
-
-    data('unicorn.languages', strings);
-
-    return this;
-  }
-
-  /**
-   * Replace all symbols to dot(.).
-   */
-  protected normalize(text: string): string {
-    return text.replace(/[^A-Z0-9]+/ig, '.');
-  }
-
-  protected wrapDebug(text: string, success: boolean): string {
-    if (isDebug()) {
-      if (success) {
-        return '**' + text + '**';
-      }
-
-      return '??' + text + '??';
-    }
-
-    return text;
-  }
-
-  getStrings(): Record<string, string> {
-    return data('unicorn.languages') || {};
-  }
-}
+import { data } from '../data';
+import { isDebug } from './/helper';
+import { Dictionary } from '../types';
+import { vsprintf } from 'sprintf-js';
+
+let lang: UnicornLang;
+
+export function useLang() {
+  return lang ??= new UnicornLang();
+}
+
+export function trans(id: string, ...args: any[]) {
+  return useLang().trans(id, ...args);
+}
+
+export function __(id: string, ...args: any[]) {
+  return trans(id, ...args);
+}
+
+export default class UnicornLang {
+  /**
+   * Translate a string.
+   */
+  trans(id: string, ...args: any[]): string {
+    const key = this.normalize(id);
+
+    let translated = this.get(key) || '';
+
+    translated = this.replace(translated, args);
+
+    return translated !== '' ? translated : this.wrapDebug(id, false);
+  }
+
+  protected replace(str: string, args: any[]): string {
+    let replacements: Dictionary<any> = {};
+    let values: any[] = [];
+
+    for (const arg of args) {
+      if (typeof arg === 'object') {
+        replacements = { ...replacements, ...arg };
+      } else {
+        values.push(arg);
+      }
+    }
+
+    if (values.length) {
+      str = vsprintf(str, values);
+    }
+
+    if (Object.values(replacements).length) {
+      for (const key in replacements) {
+        let value = replacements[key];
+
+        if (typeof value === 'function') {
+          value = value();
+        }
+
+        str = str.replace(new RegExp(':' + key, 'g'), String(value));
+      }
+    }
+
+    return str;
+  }
+
+  /**
+   * Find text.
+   */
+  get(id: string): string | null {
+    const strings = this.getStrings();
+
+    if (strings[id]) {
+      return strings[id];
+    }
+
+    return null;
+  }
+
+  /**
+   * Has language key.
+   */
+  has(key: string): boolean {
+    const strings = this.getStrings();
+
+    return strings[key] !== undefined;
+  }
+
+  /**
+   * Add language key.
+   */
+  add(key: string, value: string): this {
+    const strings = this.getStrings();
+
+    strings[this.normalize(key)] = value;
+
+    data('unicorn.languages', strings);
+
+    return this;
+  }
+
+  /**
+   * Replace all symbols to dot(.).
+   */
+  protected normalize(text: string): string {
+    return text.replace(/[^A-Z0-9]+/ig, '.');
+  }
+
+  protected wrapDebug(text: string, success: boolean): string {
+    if (isDebug()) {
+      if (success) {
+        return '**' + text + '**';
+      }
+
+      return '??' + text + '??';
+    }
+
+    return text;
+  }
+
+  getStrings(): Record<string, string> {
+    return data('unicorn.languages') || {};
+  }
+}

package/src/service/loader.ts

@@ -1,152 +1,152 @@
-import { Dictionary } from '../types';
-import { injectCssToDocument } from './';
-
-export function useScriptImport(src: string, attrs: Record<string, string> = {}): Promise<void> {
-  const script = document.createElement('script');
-  script.src = resolveUrl(src);
-
-  for (const key in attrs) {
-    script.setAttribute(key, attrs[key]);
-  }
-
-  return new Promise((resolve, reject) => {
-    script.onload = () => {
-      resolve();
-      document.body.removeChild(script);
-    };
-    script.onerror = (e) => {
-      reject(e);
-      document.body.removeChild(script);
-    };
-
-    document.body.appendChild(script);
-  });
-}
-
-export function doImport<T = any>(src: string): Promise<T> {
-  return import(/* @vite-ignore */src);
-}
-
-export async function useImport(...src: any[]): Promise<any>;
-export async function useImport<T extends any[]>(...src: string[]): Promise<T>;
-export async function useImport<T = any>(src: string): Promise<{ default: T }>;
-export async function useImport<D = any, C = any>(src: string): Promise<{ default: D } & Dictionary<C>>;
-export async function useImport(...src: any[]): Promise<any> {
-  if (src.length === 1) {
-    return doImport(src[0]);
-  }
-
-  const promises: Promise<any>[] = [];
-
-  src.forEach((link) => {
-    promises.push(
-      link instanceof Promise ? link : doImport(link)
-    );
-  });
-
-  return Promise.all(promises);
-}
-
-export async function useSeriesImport(...src: any[]): Promise<any>;
-export async function useSeriesImport<T extends any[]>(...src: string[]): Promise<T>;
-export async function useSeriesImport<T = any>(src: string): Promise<{ default: T }>;
-export async function useSeriesImport<D = any, C = any>(src: string): Promise<{ default: D } & Dictionary<C>>;
-export async function useSeriesImport(...src: any[]): Promise<any> {
-  const modules: any[] = [];
-
-  for (const source of src) {
-    if (Array.isArray(source)) {
-      const m = await useImport(...source);
-      modules.push(m);
-
-      continue;
-    }
-
-    const m = await useImport(source);
-
-    modules.push(m);
-  }
-
-  return modules;
-}
-
-export async function useCssIncludes(...hrefs: string[]): Promise<void[]> {
-  const promises = hrefs.map((href) => {
-    href = resolveUrl(href);
-
-    return new Promise<void>((resolve, reject) => {
-      const link = document.createElement('link');
-      link.rel = 'stylesheet';
-      link.href = href;
-      link.onload = () => resolve();
-      link.onerror = (e) => reject(e);
-
-      document.head.appendChild(link);
-    });
-  });
-
-  return Promise.all(promises);
-}
-
-const importedSheets: Record<string, Promise<{ default: CSSStyleSheet }>> = {};
-
-export async function useCssImport(...hrefs: string[]): Promise<CSSStyleSheet[]> {
-  // Todo: Use `{ assert: { type: "css" }` after all browsers support it.
-  const modules = await Promise.all(
-    hrefs.map((href) => {
-      if (!importedSheets[href]) {
-        importedSheets[href] = simulateCssImport(href);
-      }
-
-      return importedSheets[href];
-    })
-  );
-  const styles = modules.map(module => module.default);
-
-  return injectCssToDocument(...styles);
-}
-
-async function simulateCssImport(href: string) {
-  href = resolveUrl(href);
-
-  const response = await fetch(href);
-  if (!response.ok) {
-    throw new Error(`Failed to load CSS: ${href}`);
-  }
-  const cssText = await response.text();
-
-  const sheet = new CSSStyleSheet();
-  await sheet.replace(cssText);
-  return { default: sheet };
-}
-
-let importMap: Record<string, string>;
-
-function parseImportMap() {
-  const importMapScript = document.querySelector('script[type="importmap"]');
-  if (importMapScript) {
-    try {
-      return JSON.parse(importMapScript.textContent || '{}').imports || {};
-    } catch (e) {
-      console.error('Failed to parse import map:', e);
-    }
-  }
-  return {};
-}
-
-function resolveUrl(specifier: string) {
-  importMap ??= parseImportMap();
-
-  for (const [prefix, target] of Object.entries(importMap)) {
-    if (specifier === prefix) {
-      return target;
-    }
-  }
-
-  for (const [prefix, target] of Object.entries(importMap)) {
-    if (specifier.startsWith(prefix)) {
-      return specifier.replace(prefix, target);
-    }
-  }
-  return specifier;
-}
+import { Dictionary } from '../types';
+import { injectCssToDocument } from './';
+
+export function useScriptImport(src: string, attrs: Record<string, string> = {}): Promise<void> {
+  const script = document.createElement('script');
+  script.src = resolveUrl(src);
+
+  for (const key in attrs) {
+    script.setAttribute(key, attrs[key]);
+  }
+
+  return new Promise((resolve, reject) => {
+    script.onload = () => {
+      resolve();
+      document.body.removeChild(script);
+    };
+    script.onerror = (e) => {
+      reject(e);
+      document.body.removeChild(script);
+    };
+
+    document.body.appendChild(script);
+  });
+}
+
+export function doImport<T = any>(src: string): Promise<T> {
+  return import(/* @vite-ignore */src);
+}
+
+export async function useImport(...src: any[]): Promise<any>;
+export async function useImport<T extends any[]>(...src: string[]): Promise<T>;
+export async function useImport<T = any>(src: string): Promise<{ default: T }>;
+export async function useImport<D = any, C = any>(src: string): Promise<{ default: D } & Dictionary<C>>;
+export async function useImport(...src: any[]): Promise<any> {
+  if (src.length === 1) {
+    return doImport(src[0]);
+  }
+
+  const promises: Promise<any>[] = [];
+
+  src.forEach((link) => {
+    promises.push(
+      link instanceof Promise ? link : doImport(link)
+    );
+  });
+
+  return Promise.all(promises);
+}
+
+export async function useSeriesImport(...src: any[]): Promise<any>;
+export async function useSeriesImport<T extends any[]>(...src: string[]): Promise<T>;
+export async function useSeriesImport<T = any>(src: string): Promise<{ default: T }>;
+export async function useSeriesImport<D = any, C = any>(src: string): Promise<{ default: D } & Dictionary<C>>;
+export async function useSeriesImport(...src: any[]): Promise<any> {
+  const modules: any[] = [];
+
+  for (const source of src) {
+    if (Array.isArray(source)) {
+      const m = await useImport(...source);
+      modules.push(m);
+
+      continue;
+    }
+
+    const m = await useImport(source);
+
+    modules.push(m);
+  }
+
+  return modules;
+}
+
+export async function useCssIncludes(...hrefs: string[]): Promise<void[]> {
+  const promises = hrefs.map((href) => {
+    href = resolveUrl(href);
+
+    return new Promise<void>((resolve, reject) => {
+      const link = document.createElement('link');
+      link.rel = 'stylesheet';
+      link.href = href;
+      link.onload = () => resolve();
+      link.onerror = (e) => reject(e);
+
+      document.head.appendChild(link);
+    });
+  });
+
+  return Promise.all(promises);
+}
+
+const importedSheets: Record<string, Promise<{ default: CSSStyleSheet }>> = {};
+
+export async function useCssImport(...hrefs: string[]): Promise<CSSStyleSheet[]> {
+  // Todo: Use `{ assert: { type: "css" }` after all browsers support it.
+  const modules = await Promise.all(
+    hrefs.map((href) => {
+      if (!importedSheets[href]) {
+        importedSheets[href] = simulateCssImport(href);
+      }
+
+      return importedSheets[href];
+    })
+  );
+  const styles = modules.map(module => module.default);
+
+  return injectCssToDocument(...styles);
+}
+
+async function simulateCssImport(href: string) {
+  href = resolveUrl(href);
+
+  const response = await fetch(href);
+  if (!response.ok) {
+    throw new Error(`Failed to load CSS: ${href}`);
+  }
+  const cssText = await response.text();
+
+  const sheet = new CSSStyleSheet();
+  await sheet.replace(cssText);
+  return { default: sheet };
+}
+
+let importMap: Record<string, string>;
+
+function parseImportMap() {
+  const importMapScript = document.querySelector('script[type="importmap"]');
+  if (importMapScript) {
+    try {
+      return JSON.parse(importMapScript.textContent || '{}').imports || {};
+    } catch (e) {
+      console.error('Failed to parse import map:', e);
+    }
+  }
+  return {};
+}
+
+function resolveUrl(specifier: string) {
+  importMap ??= parseImportMap();
+
+  for (const [prefix, target] of Object.entries(importMap)) {
+    if (specifier === prefix) {
+      return target;
+    }
+  }
+
+  for (const [prefix, target] of Object.entries(importMap)) {
+    if (specifier.startsWith(prefix)) {
+      return specifier.replace(prefix, target);
+    }
+  }
+  return specifier;
+}