@quicktvui/ai 1.0.6 → 1.0.7

package/rules/.source/ESVueStyleParser/src/style-parser/named-colors.ts

@@ -0,0 +1,154 @@
+import { ColorType } from "./color-parser";
+
+export const namedColors: ColorType = {
+  transparent: 0x00000000,
+  aliceblue: 0xf0f8ffff,
+  antiquewhite: 0xfaebd7ff,
+  aqua: 0x00ffffff,
+  aquamarine: 0x7fffd4ff,
+  azure: 0xf0ffffff,
+  beige: 0xf5f5dcff,
+  bisque: 0xffe4c4ff,
+  black: 0x000000ff,
+  blanchedalmond: 0xffebcdff,
+  blue: 0x0000ffff,
+  blueviolet: 0x8a2be2ff,
+  brown: 0xa52a2aff,
+  burlywood: 0xdeb887ff,
+  burntsienna: 0xea7e5dff,
+  cadetblue: 0x5f9ea0ff,
+  chartreuse: 0x7fff00ff,
+  chocolate: 0xd2691eff,
+  coral: 0xff7f50ff,
+  cornflowerblue: 0x6495edff,
+  cornsilk: 0xfff8dcff,
+  crimson: 0xdc143cff,
+  cyan: 0x00ffffff,
+  darkblue: 0x00008bff,
+  darkcyan: 0x008b8bff,
+  darkgoldenrod: 0xb8860bff,
+  darkgray: 0xa9a9a9ff,
+  darkgreen: 0x006400ff,
+  darkgrey: 0xa9a9a9ff,
+  darkkhaki: 0xbdb76bff,
+  darkmagenta: 0x8b008bff,
+  darkolivegreen: 0x556b2fff,
+  darkorange: 0xff8c00ff,
+  darkorchid: 0x9932ccff,
+  darkred: 0x8b0000ff,
+  darksalmon: 0xe9967aff,
+  darkseagreen: 0x8fbc8fff,
+  darkslateblue: 0x483d8bff,
+  darkslategray: 0x2f4f4fff,
+  darkslategrey: 0x2f4f4fff,
+  darkturquoise: 0x00ced1ff,
+  darkviolet: 0x9400d3ff,
+  deeppink: 0xff1493ff,
+  deepskyblue: 0x00bfffff,
+  dimgray: 0x696969ff,
+  dimgrey: 0x696969ff,
+  dodgerblue: 0x1e90ffff,
+  firebrick: 0xb22222ff,
+  floralwhite: 0xfffaf0ff,
+  forestgreen: 0x228b22ff,
+  fuchsia: 0xff00ffff,
+  gainsboro: 0xdcdcdcff,
+  ghostwhite: 0xf8f8ffff,
+  gold: 0xffd700ff,
+  goldenrod: 0xdaa520ff,
+  gray: 0x808080ff,
+  green: 0x008000ff,
+  greenyellow: 0xadff2fff,
+  grey: 0x808080ff,
+  honeydew: 0xf0fff0ff,
+  hotpink: 0xff69b4ff,
+  indianred: 0xcd5c5cff,
+  indigo: 0x4b0082ff,
+  ivory: 0xfffff0ff,
+  khaki: 0xf0e68cff,
+  lavender: 0xe6e6faff,
+  lavenderblush: 0xfff0f5ff,
+  lawngreen: 0x7cfc00ff,
+  lemonchiffon: 0xfffacdff,
+  lightblue: 0xadd8e6ff,
+  lightcoral: 0xf08080ff,
+  lightcyan: 0xe0ffffff,
+  lightgoldenrodyellow: 0xfafad2ff,
+  lightgray: 0xd3d3d3ff,
+  lightgreen: 0x90ee90ff,
+  lightgrey: 0xd3d3d3ff,
+  lightpink: 0xffb6c1ff,
+  lightsalmon: 0xffa07aff,
+  lightseagreen: 0x20b2aaff,
+  lightskyblue: 0x87cefaff,
+  lightslategray: 0x778899ff,
+  lightslategrey: 0x778899ff,
+  lightsteelblue: 0xb0c4deff,
+  lightyellow: 0xffffe0ff,
+  lime: 0x00ff00ff,
+  limegreen: 0x32cd32ff,
+  linen: 0xfaf0e6ff,
+  magenta: 0xff00ffff,
+  maroon: 0x800000ff,
+  mediumaquamarine: 0x66cdaaff,
+  mediumblue: 0x0000cdff,
+  mediumorchid: 0xba55d3ff,
+  mediumpurple: 0x9370dbff,
+  mediumseagreen: 0x3cb371ff,
+  mediumslateblue: 0x7b68eeff,
+  mediumspringgreen: 0x00fa9aff,
+  mediumturquoise: 0x48d1ccff,
+  mediumvioletred: 0xc71585ff,
+  midnightblue: 0x191970ff,
+  mintcream: 0xf5fffaff,
+  mistyrose: 0xffe4e1ff,
+  moccasin: 0xffe4b5ff,
+  navajowhite: 0xffdeadff,
+  navy: 0x000080ff,
+  oldlace: 0xfdf5e6ff,
+  olive: 0x808000ff,
+  olivedrab: 0x6b8e23ff,
+  orange: 0xffa500ff,
+  orangered: 0xff4500ff,
+  orchid: 0xda70d6ff,
+  palegoldenrod: 0xeee8aaff,
+  palegreen: 0x98fb98ff,
+  paleturquoise: 0xafeeeeff,
+  palevioletred: 0xdb7093ff,
+  papayawhip: 0xffefd5ff,
+  peachpuff: 0xffdab9ff,
+  peru: 0xcd853fff,
+  pink: 0xffc0cbff,
+  plum: 0xdda0ddff,
+  powderblue: 0xb0e0e6ff,
+  purple: 0x800080ff,
+  rebeccapurple: 0x663399ff,
+  red: 0xff0000ff,
+  rosybrown: 0xbc8f8fff,
+  royalblue: 0x4169e1ff,
+  saddlebrown: 0x8b4513ff,
+  salmon: 0xfa8072ff,
+  sandybrown: 0xf4a460ff,
+  seagreen: 0x2e8b57ff,
+  seashell: 0xfff5eeff,
+  sienna: 0xa0522dff,
+  silver: 0xc0c0c0ff,
+  skyblue: 0x87ceebff,
+  slateblue: 0x6a5acdff,
+  slategray: 0x708090ff,
+  slategrey: 0x708090ff,
+  snow: 0xfffafaff,
+  springgreen: 0x00ff7fff,
+  steelblue: 0x4682b4ff,
+  tan: 0xd2b48cff,
+  teal: 0x008080ff,
+  thistle: 0xd8bfd8ff,
+  tomato: 0xff6347ff,
+  turquoise: 0x40e0d0ff,
+  violet: 0xee82eeff,
+  wheat: 0xf5deb3ff,
+  white: 0xffffffff,
+  whitesmoke: 0xf5f5f5ff,
+  yellow: 0xffff00ff,
+  yellowgreen: 0x9acd32ff,
+};

package/rules/.source/ESVueStyleParser/src/style-parser/utils.ts

@@ -0,0 +1,55 @@
+export function tryConvertNumber(raw: string): string | number {
+  const n = parseFloat(raw);
+  return isNaN(n) ? raw : n;
+}
+
+export function camelize(str: string): string {
+  return str.replace(/-(\w)/g, (_, c) => (c ? c.toUpperCase() : ""));
+}
+
+export function isLength(val: string) {
+  return /^(\d+(\.\d+)?)(px|em|rem|%)?$/.test(val);
+}
+
+export function isBorderStyle(val: string) {
+  return [
+    "none",
+    "solid",
+    "dashed",
+    "dotted",
+    "double",
+    "groove",
+    "ridge",
+    "inset",
+    "outset",
+  ].includes(val);
+}
+
+export function splitLayers(input: string): string[] {
+  const layers: string[] = [];
+  let current = "";
+  let depth = 0;
+
+  for (let i = 0; i < input.length; i++) {
+    const char = input[i];
+
+    if (char === "(") {
+      depth++;
+    } else if (char === ")") {
+      depth--;
+    }
+
+    if (char === "," && depth === 0) {
+      layers.push(current.trim());
+      current = "";
+    } else {
+      current += char;
+    }
+  }
+
+  if (current.trim()) {
+    layers.push(current.trim());
+  }
+
+  return layers;
+}

package/rules/.source/ESVueStyleParser/src/types.ts

@@ -0,0 +1,5 @@
+type Declaration = {
+  type: "declaration";
+  property: string;
+  value: any;
+};

package/rules/.source/ESVueStyleParser/tsconfig.json

@@ -0,0 +1,34 @@
+{
+  "compilerOptions": {
+    "strict": true,
+    "target": "esnext",
+    "module": "esnext",
+    "lib": [
+      "esnext",
+      "dom"
+    ],
+    "declaration": true,
+    "rootDir": ".",
+    "baseUrl": "./",
+    "outDir": "dist",
+    "jsx": "preserve",
+    "moduleResolution": "node",
+    "allowJs": false,
+    "esModuleInterop": true,
+    "noImplicitAny": false,
+    "removeComments": true,
+    "sourceMap": true
+  },
+  "include": [
+    "src/*.ts",
+    "src/*.vue",
+    "src/**/*.ts",
+    "src/**/*.vue"
+  ],
+  "exclude": [
+    "node_modules",
+    "dist",
+    "**/dist",
+    "**/node_modules"
+  ]
+}

package/rules/.source/component/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "@extscreen/es3-component",
+  "version": "3.0.0",
+  "description": "ExtScreen framework",
+  "author": "ExtScreen Team",
+  "homepage": "http://extscreen.com",
+  "license": "Apache-2.0",
+  "entry": "dist/index.js",
+  "main": "dist/index.js",
+  "module": "dist/index.js",
+  "types": "dist/src/index.d.ts",
+  "keywords": [
+    "es3-core",
+    "native",
+    "web",
+    "framework",
+    "compiler"
+  ],
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+  }
+}

package/rules/.source/component/rollup.config.js

@@ -0,0 +1,28 @@
+import vue from "rollup-plugin-vue";
+import typescript from "rollup-plugin-typescript2";
+import postcss from "rollup-plugin-postcss";
+import { terser } from "rollup-plugin-terser";
+import commonjs from "rollup-plugin-commonjs";
+import resolve from "rollup-plugin-node-resolve";
+
+export default {
+  input: "./src/index.ts",
+  output: {
+    file: "./dist/index.js",
+    format: "es",
+  },
+  plugins: [
+    typescript(),
+    vue({
+      css: true,
+      compileTemplate: true,
+    }),
+    postcss({
+      extract: "index.css",
+    }),
+    terser(),
+    commonjs(),
+    resolve(),
+  ],
+  external: ["@extscreen/es3-vue", "vue", "@extscreen/es3-core"],
+};

package/rules/.source/component/src/ESAnimationView/ESAnimationViewComponent.ts

@@ -0,0 +1,51 @@
+import { ESApp, registerElement } from "@extscreen/es3-vue";
+
+function registerESAnimationViewComponent(app: ESApp) {
+  const AnimationViewComponent = {
+    component: {
+      name: "AnimationViewComponent",
+      processEventData(
+        evtData,
+        nativeEventParams: {
+          animationId: string;
+          isReverse: boolean;
+          animatedValue: number;
+        },
+      ) {
+        const { handler: event, __evt: nativeEventName } = evtData;
+        switch (nativeEventName) {
+          case "onAnimationCancel":
+            event.animationId = nativeEventParams.animationId;
+            break;
+          case "onAnimationEnd":
+            event.animationId = nativeEventParams.animationId;
+            event.isReverse = nativeEventParams.isReverse;
+            break;
+          case "onAnimationRepeat":
+            event.animationId = nativeEventParams.animationId;
+            break;
+          case "onAnimationStart":
+            event.animationId = nativeEventParams.animationId;
+            event.isReverse = nativeEventParams.isReverse;
+            break;
+          case "onAnimationPause":
+            event.animationId = nativeEventParams.animationId;
+            break;
+          case "onAnimationResume":
+            event.animationId = nativeEventParams.animationId;
+            break;
+          case "onAnimationUpdate":
+            event.animationId = nativeEventParams.animationId;
+            event.animatedValue = nativeEventParams.animatedValue;
+            break;
+          default:
+            break;
+        }
+        return event;
+      },
+    },
+  };
+  registerElement("AnimationViewComponent", AnimationViewComponent);
+}
+
+export default registerESAnimationViewComponent;

package/rules/.source/component/src/ESAppIconView/ESAppIconViewComponent.ts

@@ -0,0 +1,46 @@
+import { h, ref } from "vue";
+import { ESApp, Native, registerElement } from "@extscreen/es3-vue";
+
+function registerESAppIconViewComponent(app: ESApp) {
+  registerElement("ESAppIconViewComponent", {
+    component: {
+      name: "ESAppIconViewComponent",
+    },
+  });
+
+  app.component("es-app-icon-view-component", {
+    setup(props, context) {
+      const viewRef = ref();
+
+      function setPackageName(packageName: string) {
+        Native.callUIFunction(
+          viewRef.value,
+          "setPackageName",
+          [packageName],
+          (res) => {},
+        );
+      }
+
+      function setRoundingRadius(roundingRadius: number) {
+        Native.callUIFunction(
+          viewRef.value,
+          "setRoundingRadius",
+          [roundingRadius],
+          (res) => {},
+        );
+      }
+
+      context.expose({
+        setPackageName,
+        setRoundingRadius,
+      });
+      return () => {
+        return h("ESAppIconViewComponent", {
+          ref: viewRef,
+        });
+      };
+    },
+  });
+}
+
+export default registerESAppIconViewComponent;

package/rules/.source/component/src/ESAppIconView/ESIAppIcon.ts

@@ -0,0 +1,5 @@
+export interface ESIAppIcon {
+  setPackageName(packageName: string);
+
+  setRoundingRadius(roundingRadius: number);
+}

package/rules/.source/component/src/ESCardView/ESCardContainerViewComponent.ts

@@ -0,0 +1,127 @@
+import { defineComponent, h, ref } from "vue";
+import { ESApp, Native, registerElement } from "@extscreen/es3-vue";
+import { ESVersion, useES } from "@extscreen/es3-core";
+import { ESCardEvent } from "./ESCardEvent";
+
+function registerESCardContainerViewComponent(app: ESApp) {
+  const cardViewComponent = {
+    component: {
+      name: "ESCardViewComponent",
+      processEventData(
+        evtData,
+        nativeEventParams: {
+          cardId: string;
+          result: number;
+          position: number;
+          eventName: string;
+          itemData: object;
+          isFocused: boolean;
+        },
+      ) {
+        const { handler: event, __evt: nativeEventName } = evtData;
+        switch (nativeEventName) {
+          case "onCardBind":
+            event.eventName = nativeEventParams.eventName;
+            event.itemData = nativeEventParams.itemData;
+            event.position = nativeEventParams.position;
+            break;
+          case "onFocus":
+            event.isFocused = nativeEventParams.isFocused;
+            break;
+          default:
+            break;
+        }
+        return event;
+      },
+    },
+  };
+  registerElement("ESCardViewComponent", cardViewComponent);
+
+  //-------------------------------------------------------------
+  const CardViewImpl = defineComponent({
+    emits: ["onCardBind", "focus"],
+    setup(props, context) {
+      const viewRef = ref();
+      const es = useES();
+
+      function load(cardId: string) {
+        Native.callUIFunction(viewRef.value, "load", [cardId], (res) => {});
+      }
+
+      function loadWithoutCache(value: string) {
+        Native.callUIFunction(viewRef.value, "loadWithoutCache", [value]);
+      }
+
+      function reload() {
+        Native.callUIFunction(viewRef.value, "reload", []);
+      }
+
+      function autoRecycle(data: boolean) {
+        Native.callUIFunction(viewRef.value, "autoRecycle", [data]);
+      }
+
+      function getLoadingStatus() {
+        Native.callUIFunction(viewRef.value, "getLoadingStatus", []);
+      }
+
+      function sendEvent2Vue(event: ESCardEvent) {
+        Native.callUIFunction(viewRef.value, "sendEvent2Vue", [event]);
+      }
+
+      function reset() {
+        Native.callUIFunction(viewRef.value, "reset", []);
+      }
+
+      function recycle() {
+        Native.callUIFunction(viewRef.value, "recycle", []);
+      }
+
+      function removeCache() {
+        Native.callUIFunction(viewRef.value, "removeCache", []);
+      }
+
+      function resizeCacheSize(size: number) {
+        Native.callUIFunction(viewRef.value, "resizeCacheSize", [size]);
+      }
+
+      function clearAllCache() {
+        Native.callUIFunction(viewRef.value, "clearAllCache", []);
+      }
+
+      context.expose({
+        load,
+        loadWithoutCache,
+        reload,
+        autoRecycle,
+        getLoadingStatus,
+        sendEvent2Vue,
+        reset,
+        recycle,
+        removeCache,
+        resizeCacheSize,
+        clearAllCache,
+      });
+      return () => {
+        let componentName = "ESCardViewComponent";
+        if (es.getESSDKVersionCode() < ESVersion.ES_SDK_VERSION_26) {
+          componentName = "div";
+        }
+        return h(componentName, {
+          ref: viewRef,
+          onCardBind: (evt) => {
+            const eventName: string = evt.eventName;
+            const itemData: any = evt.itemData;
+            const position: number = evt.position;
+            context.emit("onCardBind", eventName, position, itemData);
+          },
+          onFocus: (evt) => {
+            context.emit("focus", evt);
+          },
+        });
+      };
+    },
+  });
+  app.component("es-card-container", CardViewImpl);
+}
+
+export default registerESCardContainerViewComponent;

package/rules/.source/component/src/ESCardView/ESCardEvent.ts

@@ -0,0 +1,3 @@
+export interface ESCardEvent {
+  [prop: string]: any;
+}

package/rules/.source/component/src/ESCardView/ESCardViewComponent.ts

@@ -0,0 +1,54 @@
+import { defineComponent, h, ref } from "vue";
+import { ESApp, Native, registerElement } from "@extscreen/es3-vue";
+
+function registerESCardViewComponent(app: ESApp) {
+  registerElement("ESCardGroupView", {
+    component: {
+      name: "ESCardGroupView",
+    },
+  });
+
+  const CardGroupViewImpl = defineComponent({
+    setup(props, context) {
+      const viewRef = ref();
+
+      function load(cardId: string, useCache: boolean) {
+        Native.callUIFunction(viewRef.value, "load", [cardId, useCache]);
+      }
+
+      function reload() {
+        Native.callUIFunction(viewRef.value, "reload", []);
+      }
+
+      function showDefaultBg(data: boolean) {
+        Native.callUIFunction(viewRef.value, "showDefaultBg", [data]);
+      }
+
+      function requestCardFocus() {
+        Native.callUIFunction(viewRef.value, "requestCardFocus", []);
+      }
+
+      context.expose({
+        viewRef,
+        load,
+        reload,
+        showDefaultBg,
+        requestCardFocus,
+      });
+
+      return () => {
+        const children = context.slots.default && context.slots.default();
+        return h(
+          "ESCardGroupView",
+          {
+            ref: viewRef,
+          },
+          children,
+        );
+      };
+    },
+  });
+  app.component("es-card", CardGroupViewImpl);
+}
+
+export default registerESCardViewComponent;

package/rules/.source/component/src/ESCardView/ESICard.ts

@@ -0,0 +1,9 @@
+export interface ESICard {
+  load(cardId: string, useCache: boolean);
+
+  reload();
+
+  showDefaultBg(data: boolean);
+
+  requestCardFocus();
+}

package/rules/.source/component/src/ESCardView/ESICardContainer.ts

@@ -0,0 +1,25 @@
+import { ESCardEvent } from "./ESCardEvent";
+
+export interface ESICardContainer {
+  load(cardId: string);
+
+  loadWithoutCache(cardId: string);
+
+  reload();
+
+  autoRecycle(value: boolean);
+
+  getLoadingStatus();
+
+  sendEvent2Vue(event: ESCardEvent);
+
+  reset();
+
+  recycle();
+
+  removeCache();
+
+  resizeCacheSize(size: number);
+
+  clearAllCache();
+}

package/rules/.source/component/src/ESChartView/ESBarChartViewComponent.ts

@@ -0,0 +1,35 @@
+import { defineComponent, h, ref } from "vue";
+import { ESApp, Native, registerElement } from "@extscreen/es3-vue";
+
+function registerESBarChartViewComponent(app: ESApp) {
+  registerElement("ESBarChartViewComponent", {
+    component: {
+      name: "ESBarChartViewComponent",
+    },
+  });
+
+  const BarChartViewImpl = defineComponent({
+    name: "ESBarChartViewComponent",
+    setup(props, context) {
+      const viewRef = ref();
+
+      function setChartData(xData: Array<any>, data: Array<any>) {
+        Native.callUIFunction(viewRef.value, "setChartData", [xData, data]);
+      }
+
+      context.expose({
+        viewRef,
+        setChartData,
+      });
+
+      return () => {
+        return h("ESBarChartViewComponent", {
+          ref: viewRef,
+        });
+      };
+    },
+  });
+  app.component("es-bar-chart-view-component", BarChartViewImpl);
+}
+
+export default registerESBarChartViewComponent;

package/rules/.source/component/src/ESChartView/ESIChart.ts

@@ -0,0 +1,3 @@
+export interface ESIChart {
+  setChartData(xData: Array<any>, data: Array<any>);
+}