tauri-kargo-tools 0.2.5 → 0.2.7

package/package.json

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

package/src/api.ts

@@ -98,6 +98,9 @@ export class TauriKargoClient {
 
   typescriptTranspile(src: string): Promise<T.TypeScriptTranspileResponse> {
     return this.postJson<T.TypeScriptTranspileResponse>("/api/typescript/transpile", { src: src });
+  }
+   typescriptAst(req:T.ApiTypescriptAstRequest): Promise<T.TypescriptAstResp > {
+    return this.postJson<T.TypescriptAstResp>("/api/typescript/ast", req);
   }
   /**
    * Lire un fichier texte relatif au répertoire courant.

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)
@@ -91,17 +91,29 @@ 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 ast typescript ", async () => {
+    const client = api.createClient();
+    const config = await client.getConfig()
+    const rep = await client.explorer({})
+    await client.setCurrentDirectory({ path: config.code })
+
+    const r = await client.typescriptAst({ path: "src/api.ts" })
+    console.log(JSON.stringify(r))
+
+
+})
+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 () => {
 
     const client = api.createClient();
+    await client.setCurrentDirectory({ path: "." })
     const txt = "hello.world"
     await client.writeFileText("test.txt", txt)
     let rep = await client.explorer({})
@@ -116,7 +128,7 @@ test.test("Test read file", async () => {
 
         }), true, "pas dans rep")
     }
-
+    await client.setCurrentDirectory({ path: "." })
     const r = await client.readFileText("test.txt")
 
     test.assertEquals(r, txt)

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

@@ -242,3 +242,24 @@ export type Json =
   | string
   | Json[]
   | { [k: string]: Json };
+export type Ast = AstNode;
+
+export type AstNode = {
+  kind: string;
+  start: number;       // offset byte (0..n)
+  end: number;         // offset byte (exclu)
+  startLine: number;   // 1-based
+  startColumn: number; // 1-based (selon deno_ast view)
+  endLine: number;     // 1-based
+  endColumn: number;   // 1-based
+  children: AstNode[];
+};
+
+export type TypescriptAstOk = { ok: true; ast: Ast };
+export type TypescriptAstKo = { ok: false; error: string; position: number };
+
+export type TypescriptAstResp = TypescriptAstOk | TypescriptAstKo;
+export interface ApiTypescriptAstRequest {
+  /** Chemin relatif à `state.root` (ex: "src/main.ts") */
+  path: string;
+}