@supersoniks/concorde 4.9.93 → 4.9.95

package/src/core/components/functional/jsonata/jsonata.spec.ts

@@ -0,0 +1,202 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+import TestUtils from "@supersoniks/concorde/test-utils/TestUtils";
+import { DataProviderKey } from "@supersoniks/concorde/core/utils/dataProviderKey";
+import { deriveStateKey } from "@supersoniks/concorde/core/utils/derive";
+import { clearJsonataCache } from "@supersoniks/concorde/core/utils/jsonataRuntime";
+import { dp, set } from "@supersoniks/concorde/utils";
+import "./jsonata";
+import "../states/states";
+import {
+  DOCS_COFFEE_BAGS,
+  DOCS_SPACE_CAT_MISSIONS,
+} from "../../../../docs/mock-api/fixtures-jsonata";
+
+const missionsKey = new DataProviderKey<typeof DOCS_SPACE_CAT_MISSIONS>(
+  "jsonata-test-missions",
+);
+const formKey = new DataProviderKey<{ top: number | string }>(
+  "jsonata-test-form",
+);
+const boardKey = new DataProviderKey<
+  Array<{ name: string; points: number }>
+>("jsonata-test-board");
+
+function wait(ms: number) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+
+afterEach(() => {
+  clearJsonataCache();
+});
+
+describe("sonic-jsonata", () => {
+  it("calcule un leaderboard (groupby + top N) en live", async () => {
+    set(missionsKey, DOCS_SPACE_CAT_MISSIONS);
+    set(formKey, { top: 2 });
+
+    const [elt] = TestUtils.bootstrap(`
+      <sonic-jsonata
+        inputProvider="jsonata-test-missions"
+        outputProvider="jsonata-test-board"
+        formDataProvider="jsonata-test-form"
+        expression='$input{name: $sum(points)} ~> $each(function($v, $k) {{"name": $k, "points": $v}}) ^(>points)[[0..$number($top)-1]]'
+      ></sonic-jsonata>
+    `);
+
+    await wait(80);
+    const result = dp(boardKey).get();
+    expect(result).toHaveLength(2);
+    expect(result[0].name).toBe("Nebula Paws");
+    expect(result[0].points).toBe(75);
+    expect(result[1].name).toBe("Captain Whiskers");
+    expect(dp(deriveStateKey(boardKey)).get().status).toBe("ready");
+
+    // Comme sonic-input / sonic-select : mutation profonde sur le form DP
+    dp(formKey).top.set(1);
+    await wait(80);
+    const top1 = dp(boardKey).get();
+    const rows = Array.isArray(top1) ? top1 : [top1];
+    expect(rows).toHaveLength(1);
+    expect(rows[0].name).toBe("Nebula Paws");
+
+    (elt as HTMLElement).remove();
+  });
+
+  it("agrège le stock café par origine avec filtre roast", async () => {
+    const bagsKey = new DataProviderKey<typeof DOCS_COFFEE_BAGS>(
+      "jsonata-test-bags",
+    );
+    const coffeeForm = new DataProviderKey<{ roast: string }>(
+      "jsonata-test-coffee-form",
+    );
+    const stockKey = new DataProviderKey<Array<{ origin: string; kg: number }>>(
+      "jsonata-test-stock",
+    );
+    set(bagsKey, DOCS_COFFEE_BAGS);
+    set(coffeeForm, { roast: "light" });
+
+    const [elt] = TestUtils.bootstrap(`
+      <sonic-jsonata
+        inputProvider="jsonata-test-bags"
+        outputProvider="jsonata-test-stock"
+        formDataProvider="jsonata-test-coffee-form"
+        expression='($roast = "all" ? $input : $input[roast=$roast]){origin: $sum(kg)} ~> $each(function($v, $k) {{"origin": $k, "kg": $v}}) ^(>kg)'
+      ></sonic-jsonata>
+    `);
+
+    await wait(80);
+    const stock = dp(stockKey).get();
+    expect(stock.length).toBeGreaterThan(0);
+    expect(stock[0].origin).toBe("Ethiopia");
+    expect(stock[0].kg).toBe(16);
+    expect(stock.map((r) => r.origin)).not.toContain("Brazil");
+
+    dp(coffeeForm).roast.set("all");
+    await wait(80);
+    const all = dp(stockKey).get();
+    expect(all.map((r) => r.origin)).toContain("Brazil");
+
+    (elt as HTMLElement).remove();
+  });
+
+  it("expose status error sur expression invalide", async () => {
+    const err = vi.spyOn(console, "error").mockImplementation(() => {});
+    set(missionsKey, DOCS_SPACE_CAT_MISSIONS);
+
+    const [elt] = TestUtils.bootstrap(`
+      <sonic-jsonata
+        inputProvider="jsonata-test-missions"
+        outputProvider="jsonata-test-board"
+        expression='$input ~> $$$$invalid'
+      ></sonic-jsonata>
+    `);
+
+    await wait(80);
+    const state = dp(deriveStateKey(boardKey)).get();
+    expect(state.status).toBe("error");
+    expect(state.error).toBeTruthy();
+    err.mockRestore();
+    (elt as HTMLElement).remove();
+  });
+
+  it("branche sonic-states sur le DP /_state_", async () => {
+    set(missionsKey, DOCS_SPACE_CAT_MISSIONS);
+    set(formKey, { top: 3 });
+
+    const [wrap] = TestUtils.bootstrap(`
+      <div>
+        <sonic-jsonata
+          inputProvider="jsonata-test-missions"
+          outputProvider="jsonata-test-board"
+          formDataProvider="jsonata-test-form"
+          expression='$input[0].name'
+        ></sonic-jsonata>
+        <sonic-states dataProvider="jsonata-test-board/_state_" data-path="status">
+          <template data-value="ready"><span id="ok">prêt</span></template>
+          <template data-value="error"><span id="ko">erreur</span></template>
+        </sonic-states>
+      </div>
+    `);
+
+    await wait(80);
+    expect(wrap.querySelector("#ok")?.textContent).toBe("prêt");
+    (wrap as HTMLElement).remove();
+  });
+
+  it("calcule total + moyenne par ligne d’un tableau", async () => {
+    const linesKey = new DataProviderKey<
+      Array<{ qty: number; unitPrice: number }>
+    >("jsonata-test-lines");
+    const taxForm = new DataProviderKey<{ taxPercent: number | string }>(
+      "jsonata-test-tax-form",
+    );
+    const totalsKey = new DataProviderKey<{
+      count: number;
+      subtotal: number;
+      average: number;
+      tax: number;
+      grandTotal: number;
+    }>("jsonata-test-totals");
+
+    set(linesKey, [
+      { qty: 4, unitPrice: 3.5 },
+      { qty: 2, unitPrice: 6 },
+      { qty: 1, unitPrice: 8.5 },
+    ]);
+    set(taxForm, { taxPercent: 10 });
+
+    const [elt] = TestUtils.bootstrap(`
+      <sonic-jsonata
+        inputProvider="jsonata-test-lines"
+        outputProvider="jsonata-test-totals"
+        formDataProvider="jsonata-test-tax-form"
+        expression='(
+          $lines := $input.(qty * unitPrice);
+          {
+            "count": $count($input),
+            "subtotal": $round($sum($lines), 2),
+            "average": $round($average($lines), 2),
+            "tax": $round($sum($lines) * $number($taxPercent) / 100, 2),
+            "grandTotal": $round($sum($lines) * (1 + $number($taxPercent) / 100), 2)
+          }
+        )'
+      ></sonic-jsonata>
+    `);
+
+    await wait(80);
+    expect(dp(totalsKey).get()).toMatchObject({
+      count: 3,
+      subtotal: 34.5,
+      average: 11.5,
+      tax: 3.45,
+      grandTotal: 37.95,
+    });
+
+    dp(taxForm).taxPercent.set(20);
+    await wait(80);
+    expect(dp(totalsKey).get().tax).toBe(6.9);
+    expect(dp(totalsKey).get().grandTotal).toBe(41.4);
+
+    (elt as HTMLElement).remove();
+  });
+});

package/src/core/components/functional/jsonata/jsonata.ts

@@ -0,0 +1,116 @@
+import { LitElement, html, css } from "lit";
+import { customElement, property } from "lit/decorators.js";
+import {
+  derive,
+  type DeriveHandle,
+} from "@supersoniks/concorde/core/utils/derive";
+import {
+  compileJsonata,
+  validateOutputSchema,
+} from "@supersoniks/concorde/core/utils/jsonataRuntime";
+import { DataProviderKey } from "@supersoniks/concorde/core/utils/dataProviderKey";
+
+/**
+ * Adaptateur JSONata de `derive` : 1 entrée → expression → 1 sortie (readonly).
+ *
+ * Contexte d’évaluation :
+ * - `$input` = contenu de `inputProvider`
+ * - champs du `formDataProvider` optionnel = `$top`, `$roast`, …
+ */
+@customElement("sonic-jsonata")
+export default class SonicJsonata extends LitElement {
+  static styles = [
+    css`
+      :host {
+        display: contents;
+      }
+    `,
+  ];
+
+  /** DataProvider d’entrée (source). */
+  @property({ type: String })
+  inputProvider = "";
+
+  /** DataProvider de sortie (agrégat, readonly). */
+  @property({ type: String })
+  outputProvider = "";
+
+  /**
+   * Form / variables optionnelles (`$top`, `$roast`, …).
+   * Même id que le `formDataProvider` du formulaire — recalcule sans refetch.
+   */
+  @property({ type: String })
+  formDataProvider = "";
+
+  @property({ type: String })
+  expression = "";
+
+  @property({ type: Object })
+  outputSchema: Record<string, unknown> | null = null;
+
+  private handle: DeriveHandle | null = null;
+
+  connectedCallback(): void {
+    super.connectedCallback();
+    this.restart();
+  }
+
+  disconnectedCallback(): void {
+    this.handle?.stop();
+    this.handle = null;
+    super.disconnectedCallback();
+  }
+
+  protected updated(
+    changed: Map<string | number | symbol, unknown>,
+  ): void {
+    if (
+      changed.has("expression") ||
+      changed.has("inputProvider") ||
+      changed.has("outputProvider") ||
+      changed.has("formDataProvider") ||
+      changed.has("outputSchema")
+    ) {
+      this.restart();
+    }
+  }
+
+  private restart(): void {
+    this.handle?.stop();
+    this.handle = null;
+    if (!this.isConnected) return;
+    if (!this.inputProvider || !this.outputProvider) return;
+    if (!this.expression?.trim()) return;
+
+    const expressionSource = this.expression;
+    const schema = this.outputSchema;
+
+    this.handle = derive({
+      inputs: { input: new DataProviderKey(this.inputProvider) },
+      output: new DataProviderKey(this.outputProvider),
+      variables: this.formDataProvider
+        ? new DataProviderKey(this.formDataProvider)
+        : undefined,
+      compute: async ({ input }, vars) => {
+        const expr = compileJsonata(expressionSource);
+        const bindings: Record<string, unknown> = {
+          ...((vars ?? {}) as Record<string, unknown>),
+          input,
+        };
+        let result: unknown;
+        try {
+          result = await expr.evaluate({}, bindings);
+        } catch (err) {
+          const message = err instanceof Error ? err.message : String(err);
+          throw new Error(`[sonic-jsonata] Évaluation : ${message}`);
+        }
+        validateOutputSchema(result, schema);
+        return result;
+      },
+    });
+  }
+
+  render() {
+    return html`<slot></slot>`;
+  }
+}

package/src/core/components/ui/button/button.ts

@@ -506,8 +506,8 @@ export class Button extends FormCheckable(FormElement(Subscriber(LitElement))) {
    * L'url
    */
   private _href: Route | string = "";
-  @property({ type: String }) set href(value: Route | string) {
-    this._href = value;
+  @property({ type: String }) set href(value: Route | string | null) {
+    this._href = value ?? "";
     const str = this._href.toString();
     if (str && str.indexOf("http") != 0) {
       LocationHandler.onChange(this);

package/src/core/decorators/Subscriber.ts

@@ -4,6 +4,8 @@ export { subscribe } from "./subscriber/subscribe";
 export { onAssign } from "./subscriber/onAssign";
 export { handle, Skip } from "./subscriber/handle";
 export type { HandleOptions } from "./subscriber/handle";
+export { derive } from "./subscriber/derive";
+export type { DeriveDecoratorOptions } from "./subscriber/derive";
 export { autoSubscribe } from "./subscriber/autoSubscribe";
 export { autoFill } from "./subscriber/autoFill";
 export { ancestorAttribute } from "./subscriber/ancestorAttribute";

package/src/core/decorators/subscriber/derive.ts

@@ -0,0 +1,95 @@
+import type {
+  DataProviderKey,
+  DataProviderKeyHost,
+} from "../../utils/dataProviderKey";
+import {
+  derive as deriveFn,
+  type DeriveHandle,
+} from "../../utils/derive";
+
+export type DeriveDecoratorOptions<
+  I extends Record<string, unknown>,
+  O,
+  V = Record<string, unknown>,
+> = {
+  from: { [K in keyof I]: DataProviderKey<I[K]> };
+  to: DataProviderKey<O>;
+  /** Expression JSONata (string) ou fonction TS. */
+  expr?: string;
+  fn?: (inputs: I, vars: V) => O | Promise<O>;
+  variables?: DataProviderKey<V>;
+};
+
+const HANDLES = new WeakMap<object, DeriveHandle[]>();
+
+/**
+ * Décorateur optionnel aligné `@handle` : lance un `derive` au `connectedCallback`
+ * et l’arrête au `disconnectedCallback`.
+ *
+ * @example
+ * ```ts
+ * @derive({
+ *   from: { s: sessionsKey },
+ *   to: palmaresKey,
+ *   variables: formKey,
+ *   fn: (i, v) => i.s.slice(0, Number(v.top) || 5),
+ * })
+ * class MyWidget extends LitElement {}
+ * ```
+ */
+export function deriveDecorator<
+  I extends Record<string, unknown>,
+  O,
+  V = Record<string, unknown>,
+>(options: DeriveDecoratorOptions<I, O, V>) {
+  return function <T extends DataProviderKeyHost<object>>(
+    ctor: new (...args: any[]) => T,
+  ): void {
+    const proto = ctor.prototype as T & {
+      connectedCallback?: () => void;
+      disconnectedCallback?: () => void;
+    };
+    const connected = proto.connectedCallback;
+    const disconnected = proto.disconnectedCallback;
+
+    proto.connectedCallback = function (this: T) {
+      connected?.call(this);
+      const compute =
+        options.fn ??
+        (async (inputs: I, vars: V) => {
+          if (!options.expr) {
+            throw new Error("@derive : fournir `expr` ou `fn`.");
+          }
+          const { compileJsonata } = await import(
+            "../../utils/jsonataRuntime"
+          );
+          const expr = compileJsonata(options.expr);
+          return expr.evaluate({}, {
+            ...(vars as Record<string, unknown>),
+            ...inputs,
+          }) as O;
+        });
+      const handle = deriveFn({
+        inputs: options.from,
+        output: options.to,
+        variables: options.variables,
+        compute,
+      });
+      const list = HANDLES.get(this) ?? [];
+      list.push(handle);
+      HANDLES.set(this, list);
+    };
+
+    proto.disconnectedCallback = function (this: T) {
+      const list = HANDLES.get(this);
+      if (list) {
+        for (const h of list) h.stop();
+        HANDLES.delete(this);
+      }
+      disconnected?.call(this);
+    };
+  };
+}
+
+/** Alias public — éviter le conflit de nom avec la primitive `derive`. */
+export { deriveDecorator as derive };

package/src/core/utils/derive.spec.ts

@@ -0,0 +1,190 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { DataProviderKey } from "@supersoniks/concorde/core/utils/dataProviderKey";
+import {
+  derive,
+  deriveStateKey,
+} from "@supersoniks/concorde/core/utils/derive";
+import { dp, set } from "@supersoniks/concorde/utils";
+
+const sessionsKey = new DataProviderKey<
+  Array<{ title: string; revenue: number }>
+>("derive-sessions");
+const formKey = new DataProviderKey<{ top: number }>("derive-form");
+const outKey = new DataProviderKey<Array<{ title: string; ca: number }>>(
+  "derive-out",
+);
+const outBKey = new DataProviderKey<unknown>("derive-out-b");
+
+function wait(ms: number) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+
+afterEach(() => {
+  // Nettoyage des DPs de test
+  set(sessionsKey, []);
+  set(formKey, { top: 5 });
+  set(outKey, []);
+});
+
+describe("derive", () => {
+  it("publie un résultat calculé à partir des entrées", async () => {
+    set(sessionsKey, [
+      { title: "A", revenue: 10 },
+      { title: "B", revenue: 30 },
+    ]);
+    set(formKey, { top: 1 });
+
+    const handle = derive({
+      inputs: { s: sessionsKey },
+      variables: formKey,
+      output: outKey,
+      debounceMs: 10,
+      compute: (i, v) =>
+        [...i.s]
+          .sort((a, b) => b.revenue - a.revenue)
+          .slice(0, v.top)
+          .map((x) => ({ title: x.title, ca: x.revenue })),
+    });
+
+    await wait(40);
+    expect(dp(outKey).get()).toEqual([{ title: "B", ca: 30 }]);
+    expect(dp(deriveStateKey(outKey)).get().status).toBe("ready");
+    handle.stop();
+  });
+
+  it("recalcule quand les variables changent (sans toucher aux entrées)", async () => {
+    set(sessionsKey, [
+      { title: "A", revenue: 10 },
+      { title: "B", revenue: 30 },
+      { title: "C", revenue: 20 },
+    ]);
+    set(formKey, { top: 2 });
+
+    const handle = derive({
+      inputs: { s: sessionsKey },
+      variables: formKey,
+      output: outKey,
+      debounceMs: 10,
+      compute: (i, v) =>
+        [...i.s]
+          .sort((a, b) => b.revenue - a.revenue)
+          .slice(0, Number(v.top))
+          .map((x) => ({ title: x.title, ca: x.revenue })),
+    });
+
+    await wait(40);
+    expect(dp(outKey).get()).toHaveLength(2);
+
+    // Comme sonic-input : écriture sur la sous-clé, pas set() racine
+    dp(formKey).top.set(1);
+    await wait(40);
+    expect(dp(outKey).get()).toEqual([{ title: "B", ca: 30 }]);
+    handle.stop();
+  });
+
+  it("debounce + génération : seul le dernier calcul compte", async () => {
+    set(sessionsKey, [{ title: "A", revenue: 1 }]);
+    let calls = 0;
+
+    const handle = derive({
+      inputs: { s: sessionsKey },
+      output: outKey,
+      debounceMs: 30,
+      compute: async (i) => {
+        calls += 1;
+        const n = calls;
+        await wait(40);
+        return i.s.map((x) => ({ title: x.title + n, ca: x.revenue }));
+      },
+    });
+
+    await wait(5);
+    set(sessionsKey, [{ title: "B", revenue: 2 }]);
+    await wait(5);
+    set(sessionsKey, [{ title: "C", revenue: 3 }]);
+    await wait(120);
+
+    const result = dp(outKey).get();
+    expect(result?.[0]?.title).toMatch(/^C/);
+    handle.stop();
+  });
+
+  it("refuse un cycle direct sortie ∈ entrées", () => {
+    expect(() =>
+      derive({
+        inputs: { o: outKey },
+        output: outKey,
+        compute: (i) => i.o,
+      }),
+    ).toThrow(/Cycle/);
+  });
+
+  it("refuse un cycle en chaîne", () => {
+    const a = new DataProviderKey<number>("derive-cycle-a");
+    const b = new DataProviderKey<number>("derive-cycle-b");
+    const h1 = derive({
+      inputs: { a },
+      output: b,
+      debounceMs: 5,
+      compute: (i) => i.a + 1,
+    });
+    expect(() =>
+      derive({
+        inputs: { b },
+        output: a,
+        compute: (i) => (i.b as number) + 1,
+      }),
+    ).toThrow(/Cycle/);
+    h1.stop();
+  });
+
+  it("sortie readonly : écriture externe ignorée + warning", async () => {
+    const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
+    set(sessionsKey, [{ title: "A", revenue: 5 }]);
+    const handle = derive({
+      inputs: { s: sessionsKey },
+      output: outKey,
+      debounceMs: 10,
+      compute: (i) => i.s.map((x) => ({ title: x.title, ca: x.revenue })),
+    });
+    await wait(40);
+    expect(dp(outKey).get()).toEqual([{ title: "A", ca: 5 }]);
+
+    set(outKey, [{ title: "HACK", ca: 0 }]);
+    await wait(10);
+    expect(dp(outKey).get()).toEqual([{ title: "A", ca: 5 }]);
+    expect(warn).toHaveBeenCalled();
+    warn.mockRestore();
+    handle.stop();
+  });
+
+  it("publie status error puis empty", async () => {
+    const errSpy = vi.spyOn(console, "error").mockImplementation(() => {});
+    set(sessionsKey, [{ title: "A", revenue: 1 }]);
+    const handle = derive({
+      inputs: { s: sessionsKey },
+      output: outBKey,
+      debounceMs: 10,
+      compute: () => {
+        throw new Error("boom-jsonata");
+      },
+    });
+    await wait(40);
+    expect(dp(deriveStateKey(outBKey)).get()).toMatchObject({
+      status: "error",
+      error: expect.stringContaining("boom-jsonata"),
+    });
+    handle.stop();
+    errSpy.mockRestore();
+
+    const handle2 = derive({
+      inputs: { s: sessionsKey },
+      output: outKey,
+      debounceMs: 10,
+      compute: () => [],
+    });
+    await wait(40);
+    expect(dp(deriveStateKey(outKey)).get().status).toBe("empty");
+    handle2.stop();
+  });
+});