tauri-kargo-tools 0.2.8 → 0.3.0

package/package.json

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

package/src/schema/base.ts

@@ -10,7 +10,7 @@ export type Type<T> =
 
   | { ref: readonly (keyof T)[]; }
 
-
+  | { struct: (keyof T); }
 
   | { arrayOf: Type<T>; }
 
@@ -19,20 +19,23 @@ export type Type<T> =
 
 
 export type Structure<T> = { [name: string]: Type<T>; };
-export type EntityFieldValue = number | string | boolean | { ref: string } | EntityFieldValue[]
+export type EntityFieldValue = number | string | boolean | { ref: string } | EntityFieldValue[] | { [name: string]: EntityFieldValue }
 export type Entity = { [name: string]: EntityFieldValue }
 export type EntityMap = { [id: string]: Entity }
+export type Api<T extends { [name: string]: Structure<T>; }> = { [action: string]: Structure<T> };
+export interface World<T extends { [name: string]: Structure<T>; }, A extends Api<T>> {
+  def: T
+  api: A
+}
 
-export function createModel<T extends { [name: string]: Structure<T>; }>(def: T): T {
-  return def;
+export function createModel<T extends { [name: string]: Structure<T>; }, A extends Api<T>>(def: T, api: A): World<T, A> {
+  return { def: def, api: api };
 }
 
 
 
 export class DataModel<T extends { [name: string]: Structure<T>; }> {
-
   def: T;
-
   map: { [id: string]: ModelElement<T>; } = {};
   types: { [id: string]: keyof T } = {}
   idx = 0;
@@ -45,7 +48,31 @@ export class DataModel<T extends { [name: string]: Structure<T>; }> {
   getValues(): ModelElement<T>[] {
     return Object.values(this.map)
   }
+  attach<K extends keyof T>(ref: Ref<T, K>) {
+    const value: any = this.getValue(ref.ref)
+    if (ref.ref && this.is(value, this.types[ref.ref] as K)) {
+      ref.getValue = () => value
+      return true
+    }
+    return false
+
+  }
+  getRefs<K extends keyof T>(type: K) {
+    const refs: Ref<T, K>[] = []
+    for (const [value, refValue] of this.idForModelElement.entries()) {
+      const tmp: any = value
+      if (this.types[refValue] === type) {
+        const ref: Ref<T, K> = { ref: refValue, getValue: () => tmp }
+        refs.push(ref)
+      }
+
+    }
 
+    return refs
+
+
+
+  }
   getValue(ref: string): ModelElement<T> {
     return this.map[ref];
   }
@@ -181,7 +208,9 @@ export class DataModel<T extends { [name: string]: Structure<T>; }> {
     if (this.isOptionalType(t)) {
       return v === undefined || this.checkType(t.optional, root, v, map);
     }
-
+    if (this.isStructType(t)) {
+      return this.checkStructure(this.def[t.struct], root, v, map)
+    }
     if (this.isRefType(t)) {
       // runtime minimal : { ref: "$0" }
       if (typeof v !== "object" || v === null || Array.isArray(v)) return false;
@@ -210,6 +239,9 @@ export class DataModel<T extends { [name: string]: Structure<T>; }> {
   private isRefType(x: any): x is { ref: readonly (keyof T)[] } {
     return typeof x === "object" && x !== null && Array.isArray(x.ref);
   }
+  private isStructType(x: any): x is { struct: (keyof T) } {
+    return typeof x === "object" && x !== null && typeof x.struct === "string"
+  }
   private isArrayOfType(x: any): x is { arrayOf: Type<T> } {
     return typeof x === "object" && x !== null && "arrayOf" in x;
   }
@@ -237,9 +269,7 @@ export class DataModel<T extends { [name: string]: Structure<T>; }> {
 
 }
 
-export type RefUnion<TDefs extends { [name: string]: Structure<TDefs>; }> = {
-  [K in keyof TDefs]: Ref<TDefs, K>;
-}[keyof TDefs];
+
 
 type UnwrapOptional<V> = V extends { optional: infer O; } ? O : V;
 
@@ -267,6 +297,11 @@ type ToTsType<
 
   ? { [U in K[number]]: Ref<TDefs, U> }[K[number]]
 
+  : never
+  : V extends { struct: infer K; }
+
+  ? K extends (keyof TDefs) ? ToInterface<TDefs, K>
+
   : never
 
   : V extends { arrayOf: infer O; }
@@ -291,6 +326,50 @@ type ToTsType<
 
 // Matérialise une "entité" (clé de TDefs) en interface concrète
 
+export type ToInterfaceForStructure<
+
+  TDefs extends { [name: string]: Structure<TDefs>; },
+
+  S extends Structure<TDefs>
+
+> =
+
+  // Propriétés requises (pas 'optional')
+
+  {
+    -readonly [P in keyof S as S[P] extends { optional: any; } ? never : P]:
+
+    ToTsType<TDefs, S[P]>;
+
+  }
+
+  &
+
+  // Propriétés optionnelles ('optional')
+
+  {
+
+    -readonly [P in keyof S as S[P] extends { optional: any; } ? P : never]?:
+
+    ToTsType<TDefs, UnwrapOptional<S[P]>>;
+
+  };
+
+export interface WorldAction<T extends { [name: string]: Structure<T>; }, A extends Api<T>, K extends keyof A> {
+  type: 'doAction'
+  op: K
+  value: ToInterfaceForStructure<T, A[K]>
+}
+type Actions<TDefs extends { [name: string]: Structure<TDefs>; }, A extends Api<TDefs>> = {
+
+  [K in keyof A]: WorldAction<TDefs, A, K>;
+
+};
+type UnionActions<TDefs extends { [name: string]: Structure<TDefs>; }, A extends Api<TDefs>> = Actions<TDefs, A>[keyof A]
+export type WorldActionFonction<T extends { [name: string]: Structure<T>; }, A extends Api<T>, M extends keyof T> = (action: UnionActions<T, A>,
+  ref: Ref<T, M>
+) => boolean
+
 export type ToInterface<
 
   TDefs extends { [name: string]: Structure<TDefs>; },
@@ -489,7 +568,8 @@ export class TypeImplicationChecker<TDefs extends Def<TDefs>> {
 
 export interface DataModelReponse {
   type: 'dataModelReponse';
-  value: any;
+  value: any
+  error: boolean
 }
 export interface RefReponse {
   type: 'refReponse';

package/src/schema/client.ts

@@ -1,4 +1,4 @@
-import { Ref, Structure, ToInterface, DataModel, RefUnion } from "./base";
+import { Ref, Structure, ToInterface, DataModel, World, Api, ToInterfaceForStructure, WorldAction } from "./base";
 export type KeysOfType<T, V> = { [K in keyof T]-?: T[K] extends V ? K : never }[keyof T];
 export type Value = string | number | boolean | Value[]
 export interface DataModelProp<T extends { [name: string]: Structure<T>; }, K extends keyof T, F extends keyof ToInterface<T, K>> {
@@ -10,13 +10,13 @@ export interface DoAction<T extends { [name: string]: Structure<T>; }, K extends
   type: "doAction"
 }
 
-export class DataModelClient<T extends { [name: string]: Structure<T>; },M extends keyof T> {
-  def: T;
+export class DataModelClient<T extends { [name: string]: Structure<T>; }, M extends keyof T,A extends Api<T>> {
+  world: World<T,A>
   resolveDataModel: (dm: DataModel<T>) => void = () => { };
-  resolveRefUnion: (ref: Ref<T,M>) => void = () => { };
+  resolveRefUnion: (ref: Ref<T, M>) => void = () => { };
 
-  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" }
+  async doAction<K extends keyof A>(op: K, value: ToInterfaceForStructure<T, A[K]>): Promise<DataModel<T>> {
+    const setDataModelProp: WorldAction<T,A,K> = { type: "doAction", op: op, value: value }
     self.postMessage(JSON.parse(JSON.stringify(setDataModelProp)))
 
     const r = new Promise<DataModel<T>>((resolve) => {
@@ -32,27 +32,27 @@ export class DataModelClient<T extends { [name: string]: Structure<T>; },M exten
     })
     return r;
   }
-  async getSelf():Promise<Ref<T,M>> {
+  async getSelf(): Promise<Ref<T, M>> {
     self.postMessage({ type: "getSelf" })
-    const r = new Promise<Ref<T,M>>((resolve) => {
+    const r = new Promise<Ref<T, M>>((resolve) => {
       this.resolveRefUnion = resolve;
     })
     return r;
 
 
   }
-  constructor(def: T, type:M) {
-    this.def = def;
+  constructor(world: World<T,A>, type: M) {
+    this.world = world
     self.addEventListener("message", (event) => {
       const data = event.data;
       if (data.type === "refReponse") {
         const refReponse = data as { type: 'refReponse', ref: string };
-        const r = { ref: refReponse.ref } as Ref<T,M>;
+        const r = { ref: refReponse.ref } as Ref<T, M>;
         this.resolveRefUnion(r);
         return;
       }
       if (data.type === "dataModelReponse") {
-        const r = new DataModel<T>(this.def)
+        const r = new DataModel<T>(this.world.def)
         r.init(data.value)
         this.resolveDataModel(r);
       }

package/src/schema/server.ts

@@ -1,5 +1,5 @@
 import { set } from "../container";
-import { Ref, Structure, ToInterface, DataModel, DataModelReponse, RefUnion } from "./base";
+import { Ref, Structure, ToInterface, DataModel, DataModelReponse, World, WorldActionFonction, Api } from "./base";
 import { Value } from "./client";
 
 export interface DoAction {
@@ -12,23 +12,24 @@ export interface SimpleRef {
     ref: string
 }
 
-export class DataModelServer<T extends { [name: string]: Structure<T>; }> extends DataModel<T> {
-
-    constructor(def: T) {
-        super(def)
+export class DataModelServer<T extends { [name: string]: Structure<T>; }, M extends keyof T,A extends Api<T>> extends DataModel<T> {
+    world: World<T,A>
+    constructor(world: World<T,A>, type: M) {
+        super(world.def)
+        this.world = world
     }
-    process(worker: Worker, check: (setDataModelProp: DoAction) => boolean, ref:SimpleRef) {
+
+    process(worker: Worker, action: WorldActionFonction<T,A,  M>, ref: Ref<T, M>) {
         worker.addEventListener("message", async (event) => {
             const data = event.data;
             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());
-                }
+
+                const error = (action( { op:data.op,value:data.value,type:"doAction"}, ref))
+                worker.postMessage(this.cloneMap(error));
+
             }
             if (data.type === "getObservation") {
-                worker.postMessage(this.cloneMap());
+                worker.postMessage(this.cloneMap(false));
             }
             if (data.type === "getSelf") {
                 const refReponse = { type: 'refReponse', ref: ref.ref };
@@ -37,8 +38,8 @@ export class DataModelServer<T extends { [name: string]: Structure<T>; }> extend
         })
 
     }
-    cloneMap(): DataModelReponse {
-        return { type: 'dataModelReponse', value: JSON.parse(JSON.stringify(this.map)) };
+    cloneMap(error: boolean): DataModelReponse {
+        return { type: 'dataModelReponse', value: JSON.parse(JSON.stringify(this.map)), error: error };
     }
 
 }

package/src/test/data-model.ts

@@ -5,9 +5,20 @@ export const model = createModel({
     Cell: {
         nom: "string",
         state: "boolean",
+        p: { struct: "Point" }
     },
     Groupe: {
-        state:"boolean",
+        state: "boolean",
         membres: { arrayOf: { ref: ["Cell"] } }
+    },
+    Point: {
+        x: "number",
+        y: "number"
+    }
+}, {
+    setCell: {
+        ref: { ref: ["Cell"] },
+        value: "boolean",
+        p: { struct: "Point" }
     }
 })

package/src/test/index.ts

@@ -1,29 +1,34 @@
 import * as test from "../test"
 import * as api from '../api'
 import * as schema from "../schema/base"
-import { DataModelServer, DoAction } from "../schema/server"
+import { DataModelServer } from "../schema/server"
 import { model } from "./data-model"
+interface V {
+    ref: schema.Ref<typeof model.def, "Cell">,
+    value: schema.ToInterface<typeof model.def, "Point">
+}
+
 test.test("Test schema client server", async () => {
 
-    const server = new DataModelServer(model)
-    const state = server.createValue("Cell", { nom: "A", state: false })
+    const server = new DataModelServer(model, "Groupe")
+    const state = server.createValue("Cell", { nom: "A", state: false, p: { x: 45, y: 7 } })
     const groupe = server.createValue("Groupe", { membres: [state], state: false })
-    let resolve: (b: DoAction[]) => void = () => { }
-    const p = new Promise<DoAction[]>((r) => {
+    let resolve: (b: V) => void = () => { }
+    const p = new Promise<V>((r) => {
         resolve = r
     })
-    const m: DoAction[] = []
+
     const worker = new Worker(new URL("./worker.ts", import.meta.url), { type: "module" });
-    server.process(worker, (op) => {
-        m.push(op)
-        if (m.length >= 2) {
-            resolve(m)
+    server.process(worker, (action, ref) => {
+        if (action.op === "setCell") {
+            resolve({ ref: action.value.ref, value: action.value.p })
         }
         return true
     }, groupe)
     const v = await p
-    test.assertEquals(v[0].ref.ref === (state.ref as any), true)
-    test.assertEquals(v[1].ref.ref === (groupe.ref as any), true)
+    test.assertEquals(v.ref.ref === (state.ref as any), true)
+    test.assertEquals(v.value.x, 45)
+    test.assertEquals(v.value.y, 7)
     worker.terminate()
 
 })
@@ -95,9 +100,9 @@ test.test("Test ast typescript ", async () => {
     const client = api.createClient();
     const config = await client.getConfig()
 
-   const rep = config.code+"\\src\\api.ts"
+    const rep = config.code + "\\src\\api.ts"
 
-    const r = await client.typescriptAst({ path: rep})
+    const r = await client.typescriptAst({ path: rep })
     console.log(JSON.stringify(r))
 
 

package/src/test/worker.ts

@@ -7,20 +7,21 @@ const client = new DataModelClient(model, "Groupe");
 
 (async () => {
     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.doAction({ ref: ref, field: "state", value: true });
-                console.log(tmp.map)
-            }
-
+    const selfRef = await client.getSelf();
+    dm.attach(selfRef)
 
-        }
+    for (const ref of selfRef.getValue().membres) {
+        console.log(dm.map)
+        const tmp = await client.doAction("setCell", { ref: ref, value: false, p: ref.getValue().p });
+        console.log(tmp.map)
     }
-    const selfRef = await client.getSelf();
 
-    await client.doAction({ ref: selfRef, field: "state", value: true });
+
+
+
+
+
+
 
 
 

package/src/test.ts

@@ -12,6 +12,8 @@
 //     }
 //   });
 
+import { Assert, Log, Terminate } from "./types";
+
 type StepFn = () => void | Promise<void>;
 type TestFn = (t: { step: (name: string, fn: StepFn) => Promise<void> }) => void | Promise<void>;
 
@@ -184,7 +186,7 @@ export function deepEqual(a: unknown, b: unknown, seen = new Map<any, any>()): b
   // RegExp
   if (a instanceof RegExp || b instanceof RegExp) {
     return a instanceof RegExp && b instanceof RegExp &&
-           a.source === b.source && a.flags === b.flags;
+      a.source === b.source && a.flags === b.flags;
   }
 
   // Typed arrays
@@ -315,10 +317,35 @@ function safeStringify(v: unknown, maxDepth = 10): string {
 
 // ————— Public assert —————
 export function assertEquals(actual: unknown, expected: unknown, msg?: string): void {
-  if (deepEqual(actual, expected)) return;
+  if (deepEqual(actual, expected)) {
+    const a: Assert = { type: "assert", message: msg ?? "", value: true }
+    if (self) {
+      self.postMessage(a)
+    }
+    return;
+  };
   const aStr = safeStringify(actual);
   const eStr = safeStringify(expected);
   const defaultMsg = `assertEquals failed:\nExpected:\n${eStr}\nActual:\n${aStr}`;
+  const a: Assert = { type: "assert", message: msg ? `${msg}\n${defaultMsg}` : defaultMsg, value: false }
+  if (self) {
+    self.postMessage(a)
+  }
   throw new Error(msg ? `${msg}\n${defaultMsg}` : defaultMsg);
 }
+export function terminate() {
+  if (self) {
+    const t: Terminate = { type: "terminate" }
+    self.postMessage(t)
+  }
+}
+function log(...args: (string | number)[]) {
+  console.log(...args)
+  if (self) {
+    const log: Log = { type: "log", message: args.length == 1 ? args[0] : args }
+    self.postMessage(log)
+  }
+
+
+}
 

package/src/types.ts

@@ -262,4 +262,16 @@ export type TypescriptAstResp = TypescriptAstOk | TypescriptAstKo;
 export interface ApiTypescriptAstRequest {
   /** Chemin relatif à `state.root` (ex: "src/main.ts") */
   path: string;
+}
+export interface Assert {
+  type:'assert'
+  value:boolean
+  message:string 
+  }
+export interface Log {
+  type:'log'
+  message:(string|number)[]|string|number
+}
+export interface Terminate {
+  type:'terminate'
 }