@quicktvui/ai 1.0.5 → 1.0.7

package/rules/.source/ESRouter/src/errors.ts

@@ -0,0 +1,200 @@
+import {
+  MatcherLocationRaw,
+  MatcherLocation,
+  RouteLocationRaw,
+  RouteLocationNormalized,
+} from "./types";
+import { assign } from "./utils";
+
+/**
+ * Flags so we can combine them when checking for multiple errors. This is the internal version of
+ * {@link NavigationFailureType}.
+ *
+ * @internal
+ */
+export const enum ErrorTypes {
+  // they must be literals to be used as values, so we can't write
+  // 1 << 2
+  MATCHER_NOT_FOUND = 1,
+  NAVIGATION_GUARD_REDIRECT = 2,
+  NAVIGATION_ABORTED = 4,
+  NAVIGATION_CANCELLED = 8,
+  NAVIGATION_DUPLICATED = 16,
+}
+
+const NavigationFailureSymbol = Symbol(__DEV__ ? "navigation failure" : "");
+
+export interface MatcherError extends Error {
+  type: ErrorTypes.MATCHER_NOT_FOUND;
+  location: MatcherLocationRaw;
+  currentLocation?: MatcherLocation;
+}
+
+/**
+ * Enumeration with all possible types for navigation failures. Can be passed to
+ * {@link isNavigationFailure} to check for specific failures.
+ */
+export enum NavigationFailureType {
+  /**
+   * An aborted navigation is a navigation that failed because a navigation
+   * guard returned `false` or called `next(false)`
+   */
+  aborted = ErrorTypes.NAVIGATION_ABORTED,
+  /**
+   * A cancelled navigation is a navigation that failed because a more recent
+   * navigation finished started (not necessarily finished).
+   */
+  cancelled = ErrorTypes.NAVIGATION_CANCELLED,
+  /**
+   * A duplicated navigation is a navigation that failed because it was
+   * initiated while already being at the exact same location.
+   */
+  duplicated = ErrorTypes.NAVIGATION_DUPLICATED,
+}
+
+/**
+ * Extended Error that contains extra information regarding a failed navigation.
+ */
+export interface NavigationFailure extends Error {
+  /**
+   * Type of the navigation. One of {@link NavigationFailureType}
+   */
+  type:
+    | ErrorTypes.NAVIGATION_CANCELLED
+    | ErrorTypes.NAVIGATION_ABORTED
+    | ErrorTypes.NAVIGATION_DUPLICATED;
+  /**
+   * Route location we were navigating from
+   */
+  from: RouteLocationNormalized;
+  /**
+   * Route location we were navigating to
+   */
+  to: RouteLocationNormalized;
+}
+
+/**
+ * Internal error used to detect a redirection.
+ *
+ * @internal
+ */
+export interface NavigationRedirectError extends Omit<
+  NavigationFailure,
+  "to" | "type"
+> {
+  type: ErrorTypes.NAVIGATION_GUARD_REDIRECT;
+  to: RouteLocationRaw;
+}
+
+// DEV only debug messages
+const ErrorTypeMessages = {
+  [ErrorTypes.MATCHER_NOT_FOUND]({ location, currentLocation }: MatcherError) {
+    return `No match for\n ${JSON.stringify(location)}${
+      currentLocation
+        ? "\nwhile being at\n" + JSON.stringify(currentLocation)
+        : ""
+    }`;
+  },
+  [ErrorTypes.NAVIGATION_GUARD_REDIRECT]({
+    from,
+    to,
+  }: NavigationRedirectError) {
+    return `Redirected from "${from.fullPath}" to "${stringifyRoute(
+      to,
+    )}" via a navigation guard.`;
+  },
+  [ErrorTypes.NAVIGATION_ABORTED]({ from, to }: NavigationFailure) {
+    return `Navigation aborted from "${from.fullPath}" to "${to.fullPath}" via a navigation guard.`;
+  },
+  [ErrorTypes.NAVIGATION_CANCELLED]({ from, to }: NavigationFailure) {
+    return `Navigation cancelled from "${from.fullPath}" to "${to.fullPath}" with a new navigation.`;
+  },
+  [ErrorTypes.NAVIGATION_DUPLICATED]({ from, to }: NavigationFailure) {
+    return `Avoided redundant navigation to current location: "${from.fullPath}".`;
+  },
+};
+
+// Possible internal errors
+type RouterError = NavigationFailure | NavigationRedirectError | MatcherError;
+
+export function createRouterError<E extends RouterError>(
+  type: E["type"],
+  params: Omit<E, "type" | keyof Error>,
+): E {
+  // keep full error messages in cjs versions
+  if (__DEV__ || !__BROWSER__) {
+    return assign(
+      new Error(ErrorTypeMessages[type](params as any)),
+      {
+        type,
+        [NavigationFailureSymbol]: true,
+      } as { type: typeof type },
+      params,
+    ) as E;
+  } else {
+    return assign(
+      new Error(),
+      {
+        type,
+        [NavigationFailureSymbol]: true,
+      } as { type: typeof type },
+      params,
+    ) as E;
+  }
+}
+
+/**
+ * Check if an object is a {@link NavigationFailure}.
+ *
+ * @example
+ * ```js
+ * import { isNavigationFailure, NavigationFailureType } from 'vue-router'
+ *
+ * router.afterEach((to, from, failure) => {
+ *   // Any kind of navigation failure
+ *   if (isNavigationFailure(failure)) {
+ *     // ...
+ *   }
+ *   // Only duplicated navigations
+ *   if (isNavigationFailure(failure, NavigationFailureType.duplicated)) {
+ *     // ...
+ *   }
+ *   // Aborted or canceled navigations
+ *   if (isNavigationFailure(failure, NavigationFailureType.aborted | NavigationFailureType.canceled)) {
+ *     // ...
+ *   }
+ * })
+ * ```
+ * @param error - possible {@link NavigationFailure}
+ * @param type - optional types to check for
+ */
+export function isNavigationFailure(
+  error: any,
+  type?: ErrorTypes.NAVIGATION_GUARD_REDIRECT,
+): error is NavigationRedirectError;
+export function isNavigationFailure(
+  error: any,
+  type?: ErrorTypes | NavigationFailureType,
+): error is NavigationFailure;
+export function isNavigationFailure(
+  error: any,
+  type?: number,
+): error is NavigationFailure {
+  return (
+    error instanceof Error &&
+    NavigationFailureSymbol in error &&
+    (type == null || !!((error as unknown as NavigationFailure).type & type))
+  );
+}
+
+const propertiesToLog = ["params", "query", "hash"] as const;
+
+function stringifyRoute(to: RouteLocationRaw): string {
+  if (typeof to === "string") return to;
+  if ("path" in to) return to.path;
+  const location = {} as Record<string, unknown>;
+  for (const key of propertiesToLog) {
+    if (key in to) location[key] = to[key];
+  }
+  return JSON.stringify(location, null, 2);
+}

package/rules/.source/ESRouter/src/es/ESNativeRouter.android.ts

@@ -0,0 +1,100 @@
+import { Native } from "@extscreen/es3-vue";
+import { NativeRouteLocationRaw } from "../types";
+import { ESNativeRouter } from "./ESNativeRouter";
+
+export function createESNativeRouterForAndroid(
+  isSupportSlotType: boolean,
+): ESNativeRouter {
+  function push(to: NativeRouteLocationRaw) {
+    //
+    if (to.args) {
+      if ("name" in to.args && to.args.name) {
+        to.args.url = to.args.name;
+      }
+      if ("path" in to.args && to.args.path) {
+        to.args.url = to.args.path;
+      }
+    }
+
+    //
+    return Native.callNativeWithPromise("EsNativeModule", "launchEsPage", {
+      pkg: to.pkg, //快应用的包名
+      args: to.args,
+      flags: to.flags,
+      pageTag: to.pageTag,
+      pageLimit: to.pageLimit,
+      bgColor: to.backgroundColor,
+      splash: to.splash,
+      ver: to.version,
+      minVer: to.minVersion,
+      transparent: to.transparent,
+      isCard: to.isCard,
+      repository: to.repository,
+      uri: to.uri,
+      name: to.name,
+      icon: to.icon,
+      checkNetwork: to.checkNetwork,
+    });
+  }
+
+  function replace(to: NativeRouteLocationRaw) {
+    return Native.callNativeWithPromise("EsNativeModule", "launchEsPage", {
+      pkg: to.pkg, //快应用的包名
+      args: to.args,
+      flags: to.flags,
+      pageTag: to.pageTag,
+      pageLimit: to.pageLimit,
+      bgColor: to.backgroundColor,
+      splash: to.splash,
+      ver: to.version,
+      minVer: to.minVersion,
+      transparent: to.transparent,
+      isCard: to.isCard,
+    });
+  }
+
+  function launch(paramsArray) {
+    return Native.callNativeWithPromise(
+      "EsNativeModule",
+      "launchNativeApp",
+      paramsArray,
+    );
+  }
+
+  function launchByPackage(packageName) {
+    return Native.callNativeWithPromise(
+      "EsNativeModule",
+      "launchNativeAppWithPackage",
+      packageName,
+    );
+  }
+
+  function go(delta: number) {
+    console.log("NativeRouter:go start:" + delta);
+    if (delta < 0) {
+      console.log("NativeRouter:go " + delta + " call finish");
+      if (isSupportSlotType) {
+        console.log("NativeRouter:SlotModule invokeDefaultBackPressHandler");
+        Native.callNative("SlotModule", "invokeDefaultBackPressHandler");
+      } else {
+        console.log("NativeRouter:EsNativeModule finish");
+        Native.callNative("EsNativeModule", "finish");
+      }
+      //TODO 判断sdk版本进行处理
+      // console.log('NativeRouter:go ' + delta + ' call invokeDefaultBackPressHandler')
+      // Native.callNative('DeviceEventModule', 'invokeDefaultBackPressHandler');
+      return true;
+    }
+    return false;
+  }
+
+  return {
+    push,
+    replace,
+    launch,
+    launchByPackage,
+    go,
+    back: () => go(-1),
+    forward: () => go(1),
+  };
+}

package/rules/.source/ESRouter/src/es/ESNativeRouter.harmony.ts

@@ -0,0 +1,155 @@
+import { Native } from "@extscreen/es3-vue";
+import { NativeRouteLocationRaw } from "../types";
+import { ESNativeRouter } from "./ESNativeRouter";
+
+/**
+ *
+ */
+export function createESNativeRouterForHarmony(
+  isSupportSlotType: boolean,
+): ESNativeRouter {
+  /**
+   *
+   */
+  function push(to: NativeRouteLocationRaw) {
+    //
+    if (to.args) {
+      if ("name" in to.args && to.args.name) {
+        to.args.url = to.args.name;
+      }
+      if ("path" in to.args && to.args.path) {
+        to.args.url = to.args.path;
+      }
+    }
+
+    let jsonArgs = to.args;
+    try {
+      jsonArgs = JSON.stringify(to.args);
+    } catch (e) {}
+
+    const params = {
+      pkg: to.pkg, //快应用的包名
+      args: jsonArgs,
+      flags: to.flags,
+      pageTag: to.pageTag,
+      pageLimit: to.pageLimit,
+      bgColor: to.backgroundColor,
+      splash: to.splash,
+      ver: to.version,
+      minVer: to.minVersion,
+      transparent: to.transparent,
+      isCard: to.isCard,
+      repository: to.repository,
+      uri: to.uri,
+      name: to.name,
+      icon: to.icon,
+      checkNetwork: to.checkNetwork,
+    };
+    const query = Object.entries(params)
+      .filter(([_, v]) => v !== undefined && v !== null) // 过滤空值
+      .map(
+        ([k, v]) => `${encodeURIComponent(k)}=${encodeURIComponent(String(v))}`,
+      )
+      .join("&");
+
+    const host = to.pkg || "action"; // 如果没传包名，给个默认值防止协议错误
+    const ver = to.version || "1.0"; // 如果没传版本，给个默认值
+    const uri = `esapp://${host}/${ver}?${query}`;
+
+    return Native.callNativeWithPromise(
+      "ESNativeRouterModule",
+      "openESApp",
+      uri,
+    );
+  }
+
+  /**
+   *
+   */
+  function replace(to: NativeRouteLocationRaw) {
+    let jsonArgs = to.args;
+    try {
+      jsonArgs = JSON.stringify(to.args);
+    } catch (e) {}
+    const params = {
+      pkg: to.pkg, //快应用的包名
+      args: jsonArgs,
+      flags: to.flags,
+      pageTag: to.pageTag,
+      pageLimit: to.pageLimit,
+      bgColor: to.backgroundColor,
+      splash: to.splash,
+      ver: to.version,
+      minVer: to.minVersion,
+      transparent: to.transparent,
+      isCard: to.isCard,
+      repository: to.repository,
+      uri: to.uri,
+      name: to.name,
+      icon: to.icon,
+      checkNetwork: to.checkNetwork,
+    };
+    // 拼接 esapp 协议 URI
+    const query = Object.entries(params)
+      .filter(([_, v]) => v !== undefined && v !== null) // 过滤空值
+      .map(
+        ([k, v]) => `${encodeURIComponent(k)}=${encodeURIComponent(String(v))}`,
+      )
+      .join("&");
+
+    const host = to.pkg || "action"; // 如果没传包名，给个默认值防止协议错误
+    const ver = to.version || "1.0"; // 如果没传版本，给个默认值
+    const uri = `esapp://${host}/${ver}?${query}`;
+
+    return Native.callNativeWithPromise(
+      "ESNativeRouterModule",
+      "openESApp",
+      uri,
+    );
+  }
+
+  /**
+   *
+   */
+  function launch(link) {
+    return Native.callNativeWithPromise(
+      "ESNativeRouterModule",
+      "openLink",
+      link,
+    );
+  }
+
+  /**
+   *
+   */
+  function launchByPackage(packageName) {
+    return Promise.reject(
+      "UnsupportedOperationException: 'launchByPackage' is not supported on HarmonyOS.",
+    );
+  }
+
+  /**
+   *
+   */
+  function go(delta: number) {
+    console.log("NativeRouter:go start:" + delta);
+    if (delta < 0) {
+      console.log("NativeRouter:go " + delta + " call finish");
+      console.log("NativeRouter:ESNativeRouterModule back");
+      // Native.callNative("ESNativeRouterModule", "back");
+      Native.callNative("DeviceEventModule", "invokeDefaultBackPressHandler");
+      return true;
+    }
+    return false;
+  }
+
+  return {
+    push,
+    replace,
+    launch,
+    launchByPackage,
+    go,
+    back: () => go(-1),
+    forward: () => go(1),
+  };
+}

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

@@ -0,0 +1,24 @@
+import { NativeRouteLocationRaw } from "../types";
+import { NavigationFailure } from "../errors";
+
+export interface ESNativeRouter {
+  launch(
+    to: Array<Array<any>> | string,
+  ): Promise<NavigationFailure | void | undefined>;
+
+  launchByPackage(to: string): Promise<NavigationFailure | void | undefined>;
+
+  push(
+    to: NativeRouteLocationRaw,
+  ): Promise<NavigationFailure | void | undefined>;
+
+  replace(
+    to: NativeRouteLocationRaw,
+  ): Promise<NavigationFailure | void | undefined>;
+
+  back(): ReturnType<ESNativeRouter["go"]>;
+
+  forward(): ReturnType<ESNativeRouter["go"]>;
+
+  go(delta: number): boolean;
+}

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

@@ -0,0 +1,7 @@
+//
+export enum ESNativeRouterLaunchMode {
+  ES_NATIVE_ROUTER_LAUNCH_MODE_CLEAR_TASK = 1,
+  ES_NATIVE_ROUTER_LAUNCH_MODE_SINGLE_TASK = 2,
+  ES_NATIVE_ROUTER_LAUNCH_MODE_SINGLE_TOP = 4,
+  ES_NATIVE_ROUTER_LAUNCH_MODE_SINGLE_INSTANCE = 8,
+}

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

@@ -0,0 +1,6 @@
+//
+export enum ESNativeRouterSplash {
+  ES_NATIVE_ROUTER_SPLASH_NONE = -1, //None
+  ES_NATIVE_ROUTER_SPLASH_DEFAULT = 0, //Default
+  ES_NATIVE_ROUTER_SPLASH_SIMPLE = 1, //No Title
+}

package/rules/.source/ESRouter/src/global.d.ts

@@ -0,0 +1,15 @@
+// Global compile-time constants
+import { Component } from "vue";
+
+declare var __DEV__: boolean;
+declare var __TEST__: boolean;
+declare var __FEATURE_PROD_DEVTOOLS__: boolean;
+declare var __BROWSER__: boolean;
+declare var __NODE_JS__: boolean;
+declare var __CI__: boolean;
+
+//
+declare const __ES_ROUTER_FEATURE_FLAGS__: Partial<{
+  ROOT_VIEW_COMPONENT_NAME: string;
+  PAGE_VIEW_COMPONENT_NAME: string;
+}>;

package/rules/.source/ESRouter/src/globalExtensions.ts

@@ -0,0 +1,83 @@
+import type {
+  NavigationGuardWithThis,
+  NavigationGuard,
+  RouteLocationNormalizedLoaded,
+} from "./types";
+import { RouterView } from "./RouterView";
+import { RouterLink } from "./RouterLink";
+import { SlotView } from "./SlotView";
+import type { Router } from "./router";
+import type { TypesConfig } from "./config";
+
+// TODO: figure out why it cannot be 'vue' like said in docs
+declare module "@vue/runtime-core" {
+  export interface ComponentCustomOptions {
+    /**
+     * Guard called when the router is navigating to the route that is rendering
+     * this component from a different route. Differently from `beforeRouteUpdate`
+     * and `beforeRouteLeave`, `beforeRouteEnter` does not have access to the
+     * component instance through `this` because it triggers before the component
+     * is even mounted.
+     *
+     * @param to - RouteLocationRaw we are navigating to
+     * @param from - RouteLocationRaw we are navigating from
+     * @param next - function to validate, cancel or modify (by redirecting) the
+     * navigation
+     */
+    beforeRouteEnter?: TypesConfig extends Record<"beforeRouteEnter", infer T>
+      ? T
+      : NavigationGuardWithThis<undefined>;
+
+    /**
+     * Guard called whenever the route that renders this component has changed, but
+     * it is reused for the new route. This allows you to guard for changes in
+     * params, the query or the hash.
+     *
+     * @param to - RouteLocationRaw we are navigating to
+     * @param from - RouteLocationRaw we are navigating from
+     * @param next - function to validate, cancel or modify (by redirecting) the
+     * navigation
+     */
+    beforeRouteUpdate?: TypesConfig extends Record<"beforeRouteUpdate", infer T>
+      ? T
+      : NavigationGuard;
+
+    /**
+     * Guard called when the router is navigating away from the current route that
+     * is rendering this component.
+     *
+     * @param to - RouteLocationRaw we are navigating to
+     * @param from - RouteLocationRaw we are navigating from
+     * @param next - function to validate, cancel or modify (by redirecting) the
+     * navigation
+     */
+    beforeRouteLeave?: TypesConfig extends Record<"beforeRouteLeave", infer T>
+      ? T
+      : NavigationGuard;
+  }
+
+  export interface ComponentCustomProperties {
+    /**
+     * Normalized current location. See {@link RouteLocationNormalizedLoaded}.
+     */
+    $route: TypesConfig extends Record<"$route", infer T>
+      ? T
+      : RouteLocationNormalizedLoaded;
+    /**
+     * {@link Router} instance used by the application.
+     */
+    $router: TypesConfig extends Record<"$router", infer T> ? T : Router;
+  }
+
+  export interface GlobalComponents {
+    EsRouterView: TypesConfig extends Record<"RouterView", infer T>
+      ? T
+      : typeof RouterView;
+    EsRouterLink: TypesConfig extends Record<"RouterLink", infer T>
+      ? T
+      : typeof RouterLink;
+    EsSlotView: TypesConfig extends Record<"SlotView", infer T>
+      ? T
+      : typeof SlotView;
+  }
+}