github.com/primecitizens/pcz/std@v0.2.1/plat/js/webext/tts/bindings/ffi_bindings.ts (about)

     1  import { importModule, Application, heap, Pointer } from "@ffi";
     2  
     3  importModule("plat/js/webext/tts", (A: Application) => {
     4    const WEBEXT = typeof globalThis.browser === "undefined" ? globalThis.chrome : globalThis.browser;
     5  
     6    return {
     7      "constof_EventType": (ref: heap.Ref<string>): number => {
     8        const idx = [
     9          "start",
    10          "end",
    11          "word",
    12          "sentence",
    13          "marker",
    14          "interrupted",
    15          "cancelled",
    16          "error",
    17          "pause",
    18          "resume",
    19        ].indexOf(A.H.get(ref));
    20        return idx < 0 ? 0 : idx + 1;
    21      },
    22  
    23      "store_TtsEvent": (ptr: Pointer, ref: heap.Ref<any>) => {
    24        const x = A.H.get<any>(ref);
    25  
    26        if (typeof x === "undefined") {
    27          A.store.Bool(ptr + 40, false);
    28          A.store.Bool(ptr + 36, false);
    29          A.store.Int64(ptr + 0, 0);
    30          A.store.Ref(ptr + 8, undefined);
    31          A.store.Bool(ptr + 37, false);
    32          A.store.Bool(ptr + 12, false);
    33          A.store.Bool(ptr + 38, false);
    34          A.store.Int64(ptr + 16, 0);
    35          A.store.Bool(ptr + 39, false);
    36          A.store.Float64(ptr + 24, 0);
    37          A.store.Enum(ptr + 32, -1);
    38        } else {
    39          A.store.Bool(ptr + 40, true);
    40          A.store.Bool(ptr + 36, "charIndex" in x ? true : false);
    41          A.store.Int64(ptr + 0, x["charIndex"] === undefined ? 0 : (x["charIndex"] as number));
    42          A.store.Ref(ptr + 8, x["errorMessage"]);
    43          A.store.Bool(ptr + 37, "isFinalEvent" in x ? true : false);
    44          A.store.Bool(ptr + 12, x["isFinalEvent"] ? true : false);
    45          A.store.Bool(ptr + 38, "length" in x ? true : false);
    46          A.store.Int64(ptr + 16, x["length"] === undefined ? 0 : (x["length"] as number));
    47          A.store.Bool(ptr + 39, "srcId" in x ? true : false);
    48          A.store.Float64(ptr + 24, x["srcId"] === undefined ? 0 : (x["srcId"] as number));
    49          A.store.Enum(
    50            ptr + 32,
    51            [
    52              "start",
    53              "end",
    54              "word",
    55              "sentence",
    56              "marker",
    57              "interrupted",
    58              "cancelled",
    59              "error",
    60              "pause",
    61              "resume",
    62            ].indexOf(x["type"] as string)
    63          );
    64        }
    65      },
    66      "load_TtsEvent": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => {
    67        const x = create === A.H.TRUE ? {} : A.H.get<any>(ref);
    68  
    69        if (A.load.Bool(ptr + 36)) {
    70          x["charIndex"] = A.load.Int64(ptr + 0);
    71        } else {
    72          delete x["charIndex"];
    73        }
    74        x["errorMessage"] = A.load.Ref(ptr + 8, undefined);
    75        if (A.load.Bool(ptr + 37)) {
    76          x["isFinalEvent"] = A.load.Bool(ptr + 12);
    77        } else {
    78          delete x["isFinalEvent"];
    79        }
    80        if (A.load.Bool(ptr + 38)) {
    81          x["length"] = A.load.Int64(ptr + 16);
    82        } else {
    83          delete x["length"];
    84        }
    85        if (A.load.Bool(ptr + 39)) {
    86          x["srcId"] = A.load.Float64(ptr + 24);
    87        } else {
    88          delete x["srcId"];
    89        }
    90        x["type"] = A.load.Enum(ptr + 32, [
    91          "start",
    92          "end",
    93          "word",
    94          "sentence",
    95          "marker",
    96          "interrupted",
    97          "cancelled",
    98          "error",
    99          "pause",
   100          "resume",
   101        ]);
   102        return create === A.H.TRUE ? A.H.push(x) : ref;
   103      },
   104      "constof_VoiceGender": (ref: heap.Ref<string>): number => {
   105        const idx = ["male", "female"].indexOf(A.H.get(ref));
   106        return idx < 0 ? 0 : idx + 1;
   107      },
   108  
   109      "store_TtsOptions": (ptr: Pointer, ref: heap.Ref<any>) => {
   110        const x = A.H.get<any>(ref);
   111  
   112        if (typeof x === "undefined") {
   113          A.store.Bool(ptr + 60, false);
   114          A.store.Ref(ptr + 0, undefined);
   115          A.store.Bool(ptr + 56, false);
   116          A.store.Bool(ptr + 4, false);
   117          A.store.Ref(ptr + 8, undefined);
   118          A.store.Enum(ptr + 12, -1);
   119          A.store.Ref(ptr + 16, undefined);
   120          A.store.Ref(ptr + 20, undefined);
   121          A.store.Bool(ptr + 57, false);
   122          A.store.Float64(ptr + 24, 0);
   123          A.store.Bool(ptr + 58, false);
   124          A.store.Float64(ptr + 32, 0);
   125          A.store.Ref(ptr + 40, undefined);
   126          A.store.Ref(ptr + 44, undefined);
   127          A.store.Bool(ptr + 59, false);
   128          A.store.Float64(ptr + 48, 0);
   129        } else {
   130          A.store.Bool(ptr + 60, true);
   131          A.store.Ref(ptr + 0, x["desiredEventTypes"]);
   132          A.store.Bool(ptr + 56, "enqueue" in x ? true : false);
   133          A.store.Bool(ptr + 4, x["enqueue"] ? true : false);
   134          A.store.Ref(ptr + 8, x["extensionId"]);
   135          A.store.Enum(ptr + 12, ["male", "female"].indexOf(x["gender"] as string));
   136          A.store.Ref(ptr + 16, x["lang"]);
   137          A.store.Ref(ptr + 20, x["onEvent"]);
   138          A.store.Bool(ptr + 57, "pitch" in x ? true : false);
   139          A.store.Float64(ptr + 24, x["pitch"] === undefined ? 0 : (x["pitch"] as number));
   140          A.store.Bool(ptr + 58, "rate" in x ? true : false);
   141          A.store.Float64(ptr + 32, x["rate"] === undefined ? 0 : (x["rate"] as number));
   142          A.store.Ref(ptr + 40, x["requiredEventTypes"]);
   143          A.store.Ref(ptr + 44, x["voiceName"]);
   144          A.store.Bool(ptr + 59, "volume" in x ? true : false);
   145          A.store.Float64(ptr + 48, x["volume"] === undefined ? 0 : (x["volume"] as number));
   146        }
   147      },
   148      "load_TtsOptions": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => {
   149        const x = create === A.H.TRUE ? {} : A.H.get<any>(ref);
   150  
   151        x["desiredEventTypes"] = A.load.Ref(ptr + 0, undefined);
   152        if (A.load.Bool(ptr + 56)) {
   153          x["enqueue"] = A.load.Bool(ptr + 4);
   154        } else {
   155          delete x["enqueue"];
   156        }
   157        x["extensionId"] = A.load.Ref(ptr + 8, undefined);
   158        x["gender"] = A.load.Enum(ptr + 12, ["male", "female"]);
   159        x["lang"] = A.load.Ref(ptr + 16, undefined);
   160        x["onEvent"] = A.load.Ref(ptr + 20, undefined);
   161        if (A.load.Bool(ptr + 57)) {
   162          x["pitch"] = A.load.Float64(ptr + 24);
   163        } else {
   164          delete x["pitch"];
   165        }
   166        if (A.load.Bool(ptr + 58)) {
   167          x["rate"] = A.load.Float64(ptr + 32);
   168        } else {
   169          delete x["rate"];
   170        }
   171        x["requiredEventTypes"] = A.load.Ref(ptr + 40, undefined);
   172        x["voiceName"] = A.load.Ref(ptr + 44, undefined);
   173        if (A.load.Bool(ptr + 59)) {
   174          x["volume"] = A.load.Float64(ptr + 48);
   175        } else {
   176          delete x["volume"];
   177        }
   178        return create === A.H.TRUE ? A.H.push(x) : ref;
   179      },
   180  
   181      "store_TtsVoice": (ptr: Pointer, ref: heap.Ref<any>) => {
   182        const x = A.H.get<any>(ref);
   183  
   184        if (typeof x === "undefined") {
   185          A.store.Bool(ptr + 25, false);
   186          A.store.Ref(ptr + 0, undefined);
   187          A.store.Ref(ptr + 4, undefined);
   188          A.store.Enum(ptr + 8, -1);
   189          A.store.Ref(ptr + 12, undefined);
   190          A.store.Bool(ptr + 24, false);
   191          A.store.Bool(ptr + 16, false);
   192          A.store.Ref(ptr + 20, undefined);
   193        } else {
   194          A.store.Bool(ptr + 25, true);
   195          A.store.Ref(ptr + 0, x["eventTypes"]);
   196          A.store.Ref(ptr + 4, x["extensionId"]);
   197          A.store.Enum(ptr + 8, ["male", "female"].indexOf(x["gender"] as string));
   198          A.store.Ref(ptr + 12, x["lang"]);
   199          A.store.Bool(ptr + 24, "remote" in x ? true : false);
   200          A.store.Bool(ptr + 16, x["remote"] ? true : false);
   201          A.store.Ref(ptr + 20, x["voiceName"]);
   202        }
   203      },
   204      "load_TtsVoice": (ptr: Pointer, create: heap.Ref<boolean>, ref: heap.Ref<any>): heap.Ref<any> => {
   205        const x = create === A.H.TRUE ? {} : A.H.get<any>(ref);
   206  
   207        x["eventTypes"] = A.load.Ref(ptr + 0, undefined);
   208        x["extensionId"] = A.load.Ref(ptr + 4, undefined);
   209        x["gender"] = A.load.Enum(ptr + 8, ["male", "female"]);
   210        x["lang"] = A.load.Ref(ptr + 12, undefined);
   211        if (A.load.Bool(ptr + 24)) {
   212          x["remote"] = A.load.Bool(ptr + 16);
   213        } else {
   214          delete x["remote"];
   215        }
   216        x["voiceName"] = A.load.Ref(ptr + 20, undefined);
   217        return create === A.H.TRUE ? A.H.push(x) : ref;
   218      },
   219      "has_GetVoices": (): heap.Ref<boolean> => {
   220        if (WEBEXT?.tts && "getVoices" in WEBEXT?.tts) {
   221          return A.H.TRUE;
   222        }
   223        return A.H.FALSE;
   224      },
   225      "func_GetVoices": (fn: Pointer): void => {
   226        A.store.Ref(fn, WEBEXT.tts.getVoices);
   227      },
   228      "call_GetVoices": (retPtr: Pointer): void => {
   229        const _ret = WEBEXT.tts.getVoices();
   230        A.store.Ref(retPtr, _ret);
   231      },
   232      "try_GetVoices": (retPtr: Pointer, errPtr: Pointer): heap.Ref<boolean> => {
   233        try {
   234          const _ret = WEBEXT.tts.getVoices();
   235          A.store.Ref(retPtr, _ret);
   236          return A.H.TRUE;
   237        } catch (err: any) {
   238          A.store.Ref(errPtr, err);
   239          return A.H.FALSE;
   240        }
   241      },
   242      "has_IsSpeaking": (): heap.Ref<boolean> => {
   243        if (WEBEXT?.tts && "isSpeaking" in WEBEXT?.tts) {
   244          return A.H.TRUE;
   245        }
   246        return A.H.FALSE;
   247      },
   248      "func_IsSpeaking": (fn: Pointer): void => {
   249        A.store.Ref(fn, WEBEXT.tts.isSpeaking);
   250      },
   251      "call_IsSpeaking": (retPtr: Pointer): void => {
   252        const _ret = WEBEXT.tts.isSpeaking();
   253        A.store.Ref(retPtr, _ret);
   254      },
   255      "try_IsSpeaking": (retPtr: Pointer, errPtr: Pointer): heap.Ref<boolean> => {
   256        try {
   257          const _ret = WEBEXT.tts.isSpeaking();
   258          A.store.Ref(retPtr, _ret);
   259          return A.H.TRUE;
   260        } catch (err: any) {
   261          A.store.Ref(errPtr, err);
   262          return A.H.FALSE;
   263        }
   264      },
   265      "has_OnEvent": (): heap.Ref<boolean> => {
   266        if (WEBEXT?.tts?.onEvent && "addListener" in WEBEXT?.tts?.onEvent) {
   267          return A.H.TRUE;
   268        }
   269        return A.H.FALSE;
   270      },
   271      "func_OnEvent": (fn: Pointer): void => {
   272        A.store.Ref(fn, WEBEXT.tts.onEvent.addListener);
   273      },
   274      "call_OnEvent": (retPtr: Pointer, callback: heap.Ref<object>): void => {
   275        const _ret = WEBEXT.tts.onEvent.addListener(A.H.get<object>(callback));
   276      },
   277      "try_OnEvent": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => {
   278        try {
   279          const _ret = WEBEXT.tts.onEvent.addListener(A.H.get<object>(callback));
   280          return A.H.TRUE;
   281        } catch (err: any) {
   282          A.store.Ref(errPtr, err);
   283          return A.H.FALSE;
   284        }
   285      },
   286      "has_OffEvent": (): heap.Ref<boolean> => {
   287        if (WEBEXT?.tts?.onEvent && "removeListener" in WEBEXT?.tts?.onEvent) {
   288          return A.H.TRUE;
   289        }
   290        return A.H.FALSE;
   291      },
   292      "func_OffEvent": (fn: Pointer): void => {
   293        A.store.Ref(fn, WEBEXT.tts.onEvent.removeListener);
   294      },
   295      "call_OffEvent": (retPtr: Pointer, callback: heap.Ref<object>): void => {
   296        const _ret = WEBEXT.tts.onEvent.removeListener(A.H.get<object>(callback));
   297      },
   298      "try_OffEvent": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => {
   299        try {
   300          const _ret = WEBEXT.tts.onEvent.removeListener(A.H.get<object>(callback));
   301          return A.H.TRUE;
   302        } catch (err: any) {
   303          A.store.Ref(errPtr, err);
   304          return A.H.FALSE;
   305        }
   306      },
   307      "has_HasOnEvent": (): heap.Ref<boolean> => {
   308        if (WEBEXT?.tts?.onEvent && "hasListener" in WEBEXT?.tts?.onEvent) {
   309          return A.H.TRUE;
   310        }
   311        return A.H.FALSE;
   312      },
   313      "func_HasOnEvent": (fn: Pointer): void => {
   314        A.store.Ref(fn, WEBEXT.tts.onEvent.hasListener);
   315      },
   316      "call_HasOnEvent": (retPtr: Pointer, callback: heap.Ref<object>): void => {
   317        const _ret = WEBEXT.tts.onEvent.hasListener(A.H.get<object>(callback));
   318        A.store.Bool(retPtr, _ret);
   319      },
   320      "try_HasOnEvent": (retPtr: Pointer, errPtr: Pointer, callback: heap.Ref<object>): heap.Ref<boolean> => {
   321        try {
   322          const _ret = WEBEXT.tts.onEvent.hasListener(A.H.get<object>(callback));
   323          A.store.Bool(retPtr, _ret);
   324          return A.H.TRUE;
   325        } catch (err: any) {
   326          A.store.Ref(errPtr, err);
   327          return A.H.FALSE;
   328        }
   329      },
   330      "has_Pause": (): heap.Ref<boolean> => {
   331        if (WEBEXT?.tts && "pause" in WEBEXT?.tts) {
   332          return A.H.TRUE;
   333        }
   334        return A.H.FALSE;
   335      },
   336      "func_Pause": (fn: Pointer): void => {
   337        A.store.Ref(fn, WEBEXT.tts.pause);
   338      },
   339      "call_Pause": (retPtr: Pointer): void => {
   340        const _ret = WEBEXT.tts.pause();
   341      },
   342      "try_Pause": (retPtr: Pointer, errPtr: Pointer): heap.Ref<boolean> => {
   343        try {
   344          const _ret = WEBEXT.tts.pause();
   345          return A.H.TRUE;
   346        } catch (err: any) {
   347          A.store.Ref(errPtr, err);
   348          return A.H.FALSE;
   349        }
   350      },
   351      "has_Resume": (): heap.Ref<boolean> => {
   352        if (WEBEXT?.tts && "resume" in WEBEXT?.tts) {
   353          return A.H.TRUE;
   354        }
   355        return A.H.FALSE;
   356      },
   357      "func_Resume": (fn: Pointer): void => {
   358        A.store.Ref(fn, WEBEXT.tts.resume);
   359      },
   360      "call_Resume": (retPtr: Pointer): void => {
   361        const _ret = WEBEXT.tts.resume();
   362      },
   363      "try_Resume": (retPtr: Pointer, errPtr: Pointer): heap.Ref<boolean> => {
   364        try {
   365          const _ret = WEBEXT.tts.resume();
   366          return A.H.TRUE;
   367        } catch (err: any) {
   368          A.store.Ref(errPtr, err);
   369          return A.H.FALSE;
   370        }
   371      },
   372      "has_Speak": (): heap.Ref<boolean> => {
   373        if (WEBEXT?.tts && "speak" in WEBEXT?.tts) {
   374          return A.H.TRUE;
   375        }
   376        return A.H.FALSE;
   377      },
   378      "func_Speak": (fn: Pointer): void => {
   379        A.store.Ref(fn, WEBEXT.tts.speak);
   380      },
   381      "call_Speak": (retPtr: Pointer, utterance: heap.Ref<object>, options: Pointer): void => {
   382        const options_ffi = {};
   383  
   384        options_ffi["desiredEventTypes"] = A.load.Ref(options + 0, undefined);
   385        if (A.load.Bool(options + 56)) {
   386          options_ffi["enqueue"] = A.load.Bool(options + 4);
   387        }
   388        options_ffi["extensionId"] = A.load.Ref(options + 8, undefined);
   389        options_ffi["gender"] = A.load.Enum(options + 12, ["male", "female"]);
   390        options_ffi["lang"] = A.load.Ref(options + 16, undefined);
   391        options_ffi["onEvent"] = A.load.Ref(options + 20, undefined);
   392        if (A.load.Bool(options + 57)) {
   393          options_ffi["pitch"] = A.load.Float64(options + 24);
   394        }
   395        if (A.load.Bool(options + 58)) {
   396          options_ffi["rate"] = A.load.Float64(options + 32);
   397        }
   398        options_ffi["requiredEventTypes"] = A.load.Ref(options + 40, undefined);
   399        options_ffi["voiceName"] = A.load.Ref(options + 44, undefined);
   400        if (A.load.Bool(options + 59)) {
   401          options_ffi["volume"] = A.load.Float64(options + 48);
   402        }
   403  
   404        const _ret = WEBEXT.tts.speak(A.H.get<object>(utterance), options_ffi);
   405        A.store.Ref(retPtr, _ret);
   406      },
   407      "try_Speak": (
   408        retPtr: Pointer,
   409        errPtr: Pointer,
   410        utterance: heap.Ref<object>,
   411        options: Pointer
   412      ): heap.Ref<boolean> => {
   413        try {
   414          const options_ffi = {};
   415  
   416          options_ffi["desiredEventTypes"] = A.load.Ref(options + 0, undefined);
   417          if (A.load.Bool(options + 56)) {
   418            options_ffi["enqueue"] = A.load.Bool(options + 4);
   419          }
   420          options_ffi["extensionId"] = A.load.Ref(options + 8, undefined);
   421          options_ffi["gender"] = A.load.Enum(options + 12, ["male", "female"]);
   422          options_ffi["lang"] = A.load.Ref(options + 16, undefined);
   423          options_ffi["onEvent"] = A.load.Ref(options + 20, undefined);
   424          if (A.load.Bool(options + 57)) {
   425            options_ffi["pitch"] = A.load.Float64(options + 24);
   426          }
   427          if (A.load.Bool(options + 58)) {
   428            options_ffi["rate"] = A.load.Float64(options + 32);
   429          }
   430          options_ffi["requiredEventTypes"] = A.load.Ref(options + 40, undefined);
   431          options_ffi["voiceName"] = A.load.Ref(options + 44, undefined);
   432          if (A.load.Bool(options + 59)) {
   433            options_ffi["volume"] = A.load.Float64(options + 48);
   434          }
   435  
   436          const _ret = WEBEXT.tts.speak(A.H.get<object>(utterance), options_ffi);
   437          A.store.Ref(retPtr, _ret);
   438          return A.H.TRUE;
   439        } catch (err: any) {
   440          A.store.Ref(errPtr, err);
   441          return A.H.FALSE;
   442        }
   443      },
   444      "has_Stop": (): heap.Ref<boolean> => {
   445        if (WEBEXT?.tts && "stop" in WEBEXT?.tts) {
   446          return A.H.TRUE;
   447        }
   448        return A.H.FALSE;
   449      },
   450      "func_Stop": (fn: Pointer): void => {
   451        A.store.Ref(fn, WEBEXT.tts.stop);
   452      },
   453      "call_Stop": (retPtr: Pointer): void => {
   454        const _ret = WEBEXT.tts.stop();
   455      },
   456      "try_Stop": (retPtr: Pointer, errPtr: Pointer): heap.Ref<boolean> => {
   457        try {
   458          const _ret = WEBEXT.tts.stop();
   459          return A.H.TRUE;
   460        } catch (err: any) {
   461          A.store.Ref(errPtr, err);
   462          return A.H.FALSE;
   463        }
   464      },
   465    };
   466  });