@quicktvui/ai 1.0.6 → 1.0.7

package/rules/.source/ESRouter/src/history/common.ts

@@ -0,0 +1,237 @@
+import { isBrowser } from "../utils";
+import { removeTrailingSlash } from "../location";
+import { ComponentPublicInstance } from "vue";
+import { LifecycleState } from "../matcher/types";
+import { RouteParams } from "../types";
+import { RouteResultCallback } from "../result/RouteResultCallback";
+
+/**
+ * TODO LIULIPENG 参数转换
+ */
+export interface HistoryLocation {
+  key?: string;
+  readonly location: string;
+  instances?: ComponentPublicInstance | undefined | null;
+  lifecycle: LifecycleState;
+  saveInstanceState: {};
+  params?: RouteParams;
+  resultCallback?: RouteResultCallback;
+}
+
+/**
+ * Allowed variables in HTML5 history state. Note that pushState clones the state
+ * passed and does not accept everything: e.g.: it doesn't accept symbols, nor
+ * functions as values. It also ignores Symbols as keys.
+ *
+ * @internal
+ */
+export type HistoryStateValue =
+  | string
+  | number
+  | boolean
+  | null
+  | undefined
+  | HistoryState
+  | HistoryStateArray;
+
+/**
+ * Allowed HTML history.state
+ */
+export interface HistoryState {
+  [x: number]: HistoryStateValue;
+
+  [x: string]: HistoryStateValue;
+}
+
+/**
+ * Allowed arrays for history.state.
+ *
+ * @internal
+ */
+export interface HistoryStateArray extends Array<HistoryStateValue> {}
+
+export enum NavigationType {
+  pop = "pop",
+  push = "push",
+  splice = "splice",
+}
+
+export enum NavigationDirection {
+  back = "back",
+  forward = "forward",
+  unknown = "",
+}
+
+export interface NavigationInformation {
+  type: NavigationType;
+  direction: NavigationDirection;
+  delta: number;
+}
+
+export interface NavigationCallback {
+  (
+    to: HistoryLocation,
+    from: HistoryLocation,
+    information: NavigationInformation,
+  ): void;
+}
+
+/**
+ * Starting location for Histories
+ */
+export const START: HistoryLocation = {
+  location: "/",
+  lifecycle: LifecycleState.uninitialized,
+  saveInstanceState: {},
+};
+
+export type ValueContainer<T> = { value: T };
+
+/**
+ * Interface implemented by History implementations that can be passed to the
+ * router as {@link Router.history}
+ *
+ * @alpha
+ */
+export interface RouterHistory {
+  /**
+   * Base path that is prepended to every url. This allows hosting an SPA at a
+   * sub-folder of a domain like `example.com/sub-folder` by having a `base` of
+   * `/sub-folder`
+   */
+  readonly base: string;
+  /**
+   * Current History location
+   */
+  readonly location: HistoryLocation;
+  /**
+   * Current History state
+   */
+  readonly state: HistoryState;
+
+  // readonly location: ValueContainer<HistoryLocationNormalized>
+
+  /**
+   * Navigates to a location. In the case of an HTML5 History implementation,
+   * this will call `history.pushState` to effectively change the URL.
+   *
+   * @param to - location to push
+   * @param data - optional {@link HistoryState} to be associated with the
+   * navigation entry
+   */
+  push(to: HistoryLocation, data?: HistoryState): void;
+
+  /**
+   * Same as {@link RouterHistory.push} but performs a `history.replaceState`
+   * instead of `history.pushState`
+   *
+   * @param to - location to set
+   * @param data - optional {@link HistoryState} to be associated with the
+   * navigation entry
+   */
+  replace(to: HistoryLocation, data?: HistoryState): void;
+
+  /**
+   * Traverses history in a given direction.
+   *
+   * @example
+   * ```js
+   * myHistory.go(-1) // equivalent to window.history.back()
+   * myHistory.go(1) // equivalent to window.history.forward()
+   * ```
+   *
+   * @param delta - distance to travel. If delta is \< 0, it will go back,
+   * if it's \> 0, it will go forward by that amount of entries.
+   * @param triggerListeners - whether this should trigger listeners attached to
+   * the history
+   */
+  go(delta: number, triggerListeners?: boolean): boolean;
+
+  /**
+   *
+   * @param to
+   * @param data
+   */
+  splice(to: HistoryLocation, data?: HistoryState): boolean;
+
+  /**
+   * Attach a listener to the History implementation that is triggered when the
+   * navigation is triggered from outside (like the Browser back and forward
+   * buttons) or when passing `true` to {@link RouterHistory.back} and
+   * {@link RouterHistory.forward}
+   *
+   * @param callback - listener to attach
+   * @returns a callback to remove the listener
+   */
+  listen(callback: NavigationCallback): () => void;
+
+  /**
+   * Generates the corresponding href to be used in an anchor tag.
+   *
+   * @param location - history location that should create an href
+   */
+  createHref(location: HistoryLocation): string;
+
+  /**
+   * Clears any event listener attached by the history implementation.
+   */
+  destroy(): void;
+
+  /**
+   *
+   */
+  getLocation(): HistoryLocation;
+
+  /**
+   *
+   */
+  getHistoryLocations(): HistoryLocation[];
+
+  /**
+   *
+   */
+  clearHistoryLocations(): HistoryLocation[];
+
+  /**
+   *
+   */
+  popHistoryLocations(delta: number): HistoryLocation[];
+}
+
+// Generic utils
+
+/**
+ * Normalizes a base by removing any trailing slash and reading the base tag if
+ * present.
+ *
+ * @param base - base to normalize
+ */
+export function normalizeBase(base?: string): string {
+  if (!base) {
+    if (isBrowser) {
+      // respect <base> tag
+      const baseEl = document.querySelector("base");
+      base = (baseEl && baseEl.getAttribute("href")) || "/";
+      // strip full URL origin
+      base = base.replace(/^\w+:\/\/[^\/]+/, "");
+    } else {
+      base = "/";
+    }
+  }
+
+  // ensure leading slash when it was removed by the regex above avoid leading
+  // slash with hash because the file could be read from the disk like file://
+  // and the leading slash would cause problems
+  if (base[0] !== "/" && base[0] !== "#") base = "/" + base;
+
+  // remove the trailing slash so all other method can just do `base + fullPath`
+  // to build an href
+  return removeTrailingSlash(base);
+}
+
+// remove any character before the hash
+const BEFORE_HASH_RE = /^[^#]+#/;
+
+export function createHref(base: string, location: HistoryLocation): string {
+  return base.replace(BEFORE_HASH_RE, "#") + location;
+}

package/rules/.source/ESRouter/src/history/es.ts

@@ -0,0 +1,278 @@
+import { info } from "../log/info";
+import {
+  RouterHistory,
+  NavigationCallback,
+  NavigationType,
+  NavigationDirection,
+  NavigationInformation,
+  HistoryLocation,
+  ValueContainer,
+  START,
+} from "./common";
+
+export type ESRouterHistory = RouterHistory & {
+  position: number;
+};
+
+const TRAILING_SLASH_RE = /\/$/;
+const removeTrailingSlash = (path: string) =>
+  path.replace(TRAILING_SLASH_RE, "");
+
+// remove any character before the hash
+const BEFORE_HASH_RE = /^[^#]+#/;
+
+function createHref(base: string, location: HistoryLocation): string {
+  return `${base.replace(BEFORE_HASH_RE, "#")}${location}`;
+}
+
+/**
+ * normalize router path base
+ *
+ * @param rawBase
+ */
+function normalizeBase(rawBase?: string) {
+  let base = rawBase;
+  if (!base) {
+    base = "/";
+  }
+
+  // ensure leading slash when it was removed by the regex above avoid leading
+  // slash with hash because the file could be read from the disk like file://
+  // and the leading slash would cause problems
+  if (base[0] !== "/" && base[0] !== "#") {
+    base = `/${base}`;
+  }
+
+  // remove the trailing slash so all other method can just do `base + fullPath`
+  // to build a href
+  return removeTrailingSlash(base);
+}
+
+/**
+ * Create an in-memory based history. similar with memory history in vue-router.
+ * the only different is this history mode support hardware back press for android.
+ *
+ * @public
+ */
+export function createESHistory(rawBase = ""): ESRouterHistory {
+  // history queue
+  let queue: HistoryLocation[] = [START];
+  // current position
+  let position = 0;
+  let listeners: NavigationCallback[] = [];
+  // normalize base
+  const base = normalizeBase(rawBase);
+  //
+  let currentLocation: ValueContainer<HistoryLocation> = {
+    value: START,
+  };
+
+  function setLocation(location: HistoryLocation): void {
+    position += 1;
+    queue.push(location);
+    info(
+      "history::setLocation",
+      "position:" + position,
+      "queue:",
+      queue.length,
+    );
+  }
+
+  function triggerListeners(
+    to: HistoryLocation,
+    from: HistoryLocation,
+    { direction, delta }: Pick<NavigationInformation, "direction" | "delta">,
+  ): void {
+    const info: NavigationInformation = {
+      direction,
+      delta,
+      type: NavigationType.pop,
+    };
+
+    for (const callback of listeners) {
+      callback(to, from, info);
+    }
+  }
+
+  const routerHistory: ESRouterHistory = {
+    // rewritten by Object.defineProperty
+    location: START,
+    state: {},
+    base,
+    createHref: createHref.bind(null, base),
+
+    replace(to) {
+      info(
+        "history::replace start...",
+        "position:" + position,
+        "queue:",
+        queue.length,
+      );
+      queue.splice(position, 1);
+      //
+      position -= 1;
+      setLocation(to);
+      currentLocation.value = to;
+      info(
+        "history::replace end...",
+        "position:" + position,
+        "queue:",
+        queue.length,
+      );
+    },
+
+    push(to: HistoryLocation) {
+      setLocation(to);
+      currentLocation.value = to;
+      info("history::push", "position:" + position, "queue:", queue.length);
+    },
+
+    splice(to: HistoryLocation) {
+      info(
+        "history::splice start...",
+        "position:" + position,
+        "queue:",
+        queue.length,
+      );
+      const index = queue.findIndex(
+        (location) =>
+          location.key == to.key && location.location == to.location,
+      );
+      if (index > -1) {
+        const location: HistoryLocation = queue[index];
+        position = Math.min(position - 1, queue.length - 1);
+        if (position < 0) {
+          queue = [START];
+          currentLocation.value = START;
+        } else {
+          queue.splice(index, 1);
+          currentLocation.value = queue[queue.length - 1];
+        }
+        const direction: NavigationDirection = NavigationDirection.back;
+        const from = currentLocation.value;
+        const delta: number = -1;
+        triggerListeners(currentLocation.value, location, {
+          direction,
+          delta,
+        });
+        return true;
+      }
+      return false;
+    },
+
+    listen(callback: NavigationCallback) {
+      listeners.push(callback);
+
+      return () => {
+        const index = listeners.indexOf(callback);
+        if (index > -1) {
+          listeners.splice(index, 1);
+        }
+      };
+    },
+
+    destroy() {
+      listeners = [];
+      queue = [START];
+      position = 0;
+      currentLocation.value = START;
+    },
+    go(delta: number, shouldTrigger = true): boolean {
+      info("history::go start", "position:" + position);
+      if (position + delta < 0) {
+        return false;
+      }
+      const from = currentLocation.value;
+      const direction: NavigationDirection =
+        delta < 0 ? NavigationDirection.back : NavigationDirection.forward;
+      position = Math.min(position + delta, queue.length - 1);
+
+      info("history::go ", "queue:" + queue.length, "position:" + position);
+
+      if (position <= 0) {
+        queue = [START];
+        currentLocation.value = START;
+        return false;
+      } else {
+        queue.splice(position + 1);
+        currentLocation.value = queue[queue.length - 1];
+      }
+      if (shouldTrigger) {
+        triggerListeners(currentLocation.value, from, {
+          direction,
+          delta,
+        });
+      }
+      return true;
+    },
+
+    get position(): number {
+      return position;
+    },
+
+    getLocation(): HistoryLocation {
+      return currentLocation.value;
+    },
+
+    getHistoryLocations(): HistoryLocation[] {
+      return queue;
+    },
+
+    clearHistoryLocations(): HistoryLocation[] {
+      info(
+        "history::clearHistoryLocations start...",
+        "position:" + position,
+        "queue:",
+        queue.length,
+      );
+      let ret = [...queue];
+      queue = [START];
+      position = 0;
+      currentLocation.value = START;
+      info(
+        "history::clearHistoryLocations end...",
+        "position:" + position,
+        "queue:",
+        queue.length,
+      );
+      return ret;
+    },
+
+    popHistoryLocations(delta: number): HistoryLocation[] {
+      info(
+        "history::popHistoryLocations start...",
+        "delta:" + delta,
+        "position:" + position,
+        "queue:",
+        queue.length,
+      );
+      if (delta < queue.length) {
+        position -= delta;
+        let index = queue.length - delta;
+        let ret = queue.splice(index, delta);
+        currentLocation.value = queue[queue.length - 1];
+        info(
+          "history::popHistoryLocations end...",
+          "delta:" + delta,
+          "position:" + position,
+          "queue:",
+          queue.length,
+        );
+        return ret;
+      } else if (delta >= queue.length) {
+        queue = [START];
+        position = 0;
+        currentLocation.value = START;
+        info(
+          "history::popHistoryLocations end...",
+          "delta:" + delta,
+          "position:" + position,
+          "queue:",
+          queue.length,
+        );
+        return queue;
+      }
+    },
+  };
+  return routerHistory;
+}

package/rules/.source/ESRouter/src/history/hash.ts

@@ -0,0 +1,46 @@
+import { RouterHistory } from "./common";
+import { createWebHistory } from "./html5";
+import { warn } from "../warning";
+
+/**
+ * Creates a hash history. Useful for web applications with no host (e.g. `file://`) or when configuring a server to
+ * handle any URL is not possible.
+ *
+ * @param base - optional base to provide. Defaults to `location.pathname + location.search` If there is a `<base>` tag
+ * in the `head`, its value will be ignored in favor of this parameter **but note it affects all the history.pushState()
+ * calls**, meaning that if you use a `<base>` tag, it's `href` value **has to match this parameter** (ignoring anything
+ * after the `#`).
+ *
+ * @example
+ * ```js
+ * // at https://example.com/folder
+ * createWebHashHistory() // gives a url of `https://example.com/folder#`
+ * createWebHashHistory('/folder/') // gives a url of `https://example.com/folder/#`
+ * // if the `#` is provided in the base, it won't be added by `createWebHashHistory`
+ * createWebHashHistory('/folder/#/app/') // gives a url of `https://example.com/folder/#/app/`
+ * // you should avoid doing this because it changes the original url and breaks copying urls
+ * createWebHashHistory('/other-folder/') // gives a url of `https://example.com/other-folder/#`
+ *
+ * // at file:///usr/etc/folder/index.html
+ * // for locations with no `host`, the base is ignored
+ * createWebHashHistory('/iAmIgnored') // gives a url of `file:///usr/etc/folder/index.html#`
+ * ```
+ */
+export function createWebHashHistory(base?: string): RouterHistory {
+  // Make sure this implementation is fine in terms of encoding, specially for IE11
+  // for `file://`, directly use the pathname and ignore the base
+  // location.pathname contains an initial `/` even at the root: `https://example.com`
+  base = location.host ? base || location.pathname + location.search : "";
+  // allow the user to provide a `#` in the middle: `/base/#/app`
+  if (!base.includes("#")) base += "#";
+
+  if (__DEV__ && !base.endsWith("#/") && !base.endsWith("#")) {
+    warn(
+      `A hash base must end with a "#":\n"${base}" should be "${base.replace(
+        /#.*$/,
+        "#",
+      )}".`,
+    );
+  }
+  return createWebHistory(base);
+}