tauri-kargo-tools 0.2.4 → 0.2.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tauri-kargo-tools",
-  "version": "0.2.4",
+  "version": "0.2.6",
   "description": "",
    "files": ["src"],
  "exports": { "./*": "./src/*" },

package/src/api.ts

@@ -95,6 +95,10 @@ export class TauriKargoClient {
   createDirectory(path: string): Promise<T.CreateDirResp> {
     return this.postJson<T.CreateDirResp>("/api/directory/create", { path: path });
   }
+
+  typescriptTranspile(src: string): Promise<T.TypeScriptTranspileResponse> {
+    return this.postJson<T.TypeScriptTranspileResponse>("/api/typescript/transpile", { src: src });
+  }
   /**
    * Lire un fichier texte relatif au répertoire courant.
    * (POST sans corps ⇒ READ ; renvoie text/plain ou octet-stream)

package/src/schema/client.ts

@@ -6,8 +6,8 @@ export interface DataModelProp<T extends { [name: string]: Structure<T>; }, K ex
   field: F
   value: ToInterface<T, K>[F]
 }
-export interface SetDataModelProp<T extends { [name: string]: Structure<T>; }, K extends keyof T, F extends keyof ToInterface<T, K>> extends DataModelProp<T, K, F> {
-  type: "setDataModelProp"
+export interface DoAction<T extends { [name: string]: Structure<T>; }, K extends keyof T, F extends keyof ToInterface<T, K>> extends DataModelProp<T, K, F> {
+  type: "doAction"
 }
 
 export class DataModelClient<T extends { [name: string]: Structure<T>; }> {
@@ -15,8 +15,8 @@ export class DataModelClient<T extends { [name: string]: Structure<T>; }> {
   resolveDataModel: (dm: DataModel<T>) => void = () => { };
   resolveRefUnion: (ref: RefUnion<T>) => void = () => { };
 
-  async setProp<K extends keyof T, F extends KeysOfType<ToInterface<T, K>, Value>>(dvp: DataModelProp<T, K, F>): Promise<DataModel<T>> {
-    const setDataModelProp: SetDataModelProp<T, K, F> = { ...dvp, type: "setDataModelProp" }
+  async doAction<K extends keyof T, F extends KeysOfType<ToInterface<T, K>, Value>>(dvp: DataModelProp<T, K, F>): Promise<DataModel<T>> {
+    const setDataModelProp: DoAction<T, K, F> = { ...dvp, type: "doAction" }
     self.postMessage(JSON.parse(JSON.stringify(setDataModelProp)))
 
     const r = new Promise<DataModel<T>>((resolve) => {
@@ -25,8 +25,8 @@ export class DataModelClient<T extends { [name: string]: Structure<T>; }> {
     return r;
 
   }
-  async getDataModel(): Promise<DataModel<T>> {
-    self.postMessage({ type: "getDataModel" })
+  async getObservation(): Promise<DataModel<T>> {
+    self.postMessage({ type: "getObservation" })
     const r = new Promise<DataModel<T>>((resolve) => {
       this.resolveDataModel = resolve;
     })

package/src/schema/server.ts

@@ -2,8 +2,8 @@ import { set } from "../container";
 import { Ref, Structure, ToInterface, DataModel, DataModelReponse, RefUnion } from "./base";
 import { Value } from "./client";
 
-export interface SetDataModelProp {
-    type: "setDataModelProp",
+export interface DoAction {
+    type: "doAction",
     ref: { ref: string }
     field: string
     value: Value
@@ -17,17 +17,17 @@ export class DataModelServer<T extends { [name: string]: Structure<T>; }> extend
     constructor(def: T) {
         super(def)
     }
-    process(worker: Worker, check: (setDataModelProp: SetDataModelProp) => boolean, ref:SimpleRef) {
+    process(worker: Worker, check: (setDataModelProp: DoAction) => boolean, ref:SimpleRef) {
         worker.addEventListener("message", async (event) => {
             const data = event.data;
-            if (data.type === "setDataModelProp") {
-                const setDataModelProp = data as SetDataModelProp;
+            if (data.type === "doAction") {
+                const setDataModelProp = data as DoAction;
                 if (check(setDataModelProp)) {
                     this.initField(setDataModelProp.ref.ref, setDataModelProp.field, setDataModelProp.value);
                     worker.postMessage(this.cloneMap());
                 }
             }
-            if (data.type === "getDataModel") {
+            if (data.type === "getObservation") {
                 worker.postMessage(this.cloneMap());
             }
             if (data.type === "getSelf") {

package/src/test/index.ts

@@ -1,18 +1,18 @@
 import * as test from "../test"
 import * as api from '../api'
 import * as schema from "../schema/base"
-import { DataModelServer, SetDataModelProp } from "../schema/server"
+import { DataModelServer, DoAction } from "../schema/server"
 import { model } from "./data-model"
 test.test("Test schema client server", async () => {
 
     const server = new DataModelServer(model)
     const state = server.createValue("Cell", { nom: "A", state: false })
     const groupe = server.createValue("Groupe", { membres: [state], state: false })
-    let resolve: (b: SetDataModelProp[]) => void = () => { }
-    const p = new Promise<SetDataModelProp[]>((r) => {
+    let resolve: (b: DoAction[]) => void = () => { }
+    const p = new Promise<DoAction[]>((r) => {
         resolve = r
     })
-    const m: SetDataModelProp[] = []
+    const m: DoAction[] = []
     const worker = new Worker(new URL("./worker.ts", import.meta.url), { type: "module" });
     server.process(worker, (op) => {
         m.push(op)
@@ -90,6 +90,14 @@ test.test("Test schema simple avec deux type", async () => {
 
 
 
+})
+test.test("Test transpile ", async()=> {
+      const client = api.createClient();
+      const src = `  function m( n:number) { return n+1}`
+      const r = await client.typescriptTranspile(src)
+      console.log(JSON.stringify(r))
+
+
 })
 test.test("Test read file", async () => {
 

package/src/test/worker.ts

@@ -6,12 +6,12 @@ const client = new DataModelClient(model);
 
 
 (async () => {
-    const dm = await client.getDataModel();
+    const dm = await client.getObservation();
     for (const o of dm.getValues()) {
         if (dm.is(o, "Groupe")) {
             for (const ref of o.membres) {
                 console.log(dm.map)
-                const tmp = await client.setProp({ ref: ref, field: "state", value: true });
+                const tmp = await client.doAction({ ref: ref, field: "state", value: true });
                 console.log(tmp.map)
             }
 
@@ -20,7 +20,7 @@ const client = new DataModelClient(model);
     }
     const selfRef = await client.getSelf();
     if (dm.isRef(selfRef, "Groupe")) {
-        await client.setProp({ ref: selfRef, field: "state", value: true });
+        await client.doAction({ ref: selfRef, field: "state", value: true });
     }
 
 

package/src/types.ts

@@ -104,7 +104,14 @@ export interface StopAllResp {
   ok: boolean;
   message: string;
 }
+export type TypeScriptTranspileInput = { src: string };
 
+export type TypeScriptTranspileSuccess = { ok: true; src: string };
+
+export type TypeScriptTranspileError = { ok: false; message: string };
+
+export type TypeScriptTranspileResponse = TypeScriptTranspileSuccess | TypeScriptTranspileError;
+ 
 export interface ExplorerReq {
   path?: string;
 }