@oneclick.dev/cms-core-modules 0.0.122 → 0.0.124

package/dist/src/table/tools.d.ts

@@ -1 +1,333 @@
-export declare const tools: never[];
+export declare const tools: ({
+    name: string;
+    description: string;
+    executionMode: string;
+    chatComponent: string;
+    parameters: {
+        type: string;
+        properties: {
+            sampleLimit: {
+                type: string;
+                description: string;
+                default: number;
+                minimum: number;
+                maximum: number;
+            };
+            startDate?: undefined;
+            endDate?: undefined;
+            dateProperty?: undefined;
+            useDefaultDateRange?: undefined;
+            filters?: undefined;
+            sortBy?: undefined;
+            sortDirection?: undefined;
+            columns?: undefined;
+            limit?: undefined;
+            title?: undefined;
+            view?: undefined;
+            operation?: undefined;
+            property?: undefined;
+            groupBy?: undefined;
+            code?: undefined;
+            precision?: undefined;
+            action?: undefined;
+            match?: undefined;
+            confirmationMessage?: undefined;
+        };
+        required: never[];
+        additionalProperties: boolean;
+    };
+} | {
+    name: string;
+    description: string;
+    executionMode: string;
+    chatComponent: string;
+    parameters: {
+        type: string;
+        properties: {
+            startDate: {
+                type: string;
+                format: string;
+                description: string;
+            };
+            endDate: {
+                type: string;
+                format: string;
+                description: string;
+            };
+            dateProperty: {
+                type: string;
+                description: string;
+            };
+            useDefaultDateRange: {
+                type: string;
+                description: string;
+                default: boolean;
+            };
+            filters: {
+                type: string;
+                description: string;
+                default: never[];
+                items: {
+                    type: string;
+                    properties: {
+                        property: {
+                            type: string;
+                            description: string;
+                        };
+                        operator: {
+                            type: string;
+                            enum: string[];
+                            description: string;
+                        };
+                        value: {
+                            description: string;
+                            anyOf: {
+                                type: string;
+                            }[];
+                        };
+                        values: {
+                            type: string;
+                            description: string;
+                            items: {
+                                anyOf: {
+                                    type: string;
+                                }[];
+                            };
+                        };
+                    };
+                    required: string[];
+                    additionalProperties: boolean;
+                };
+            };
+            sortBy: {
+                type: string;
+                description: string;
+            };
+            sortDirection: {
+                type: string;
+                enum: string[];
+                description: string;
+                default: string;
+            };
+            columns: {
+                type: string;
+                description: string;
+                items: {
+                    type: string;
+                };
+                uniqueItems: boolean;
+            };
+            limit: {
+                type: string;
+                description: string;
+                default: number;
+                minimum: number;
+                maximum: number;
+            };
+            title: {
+                type: string;
+                description: string;
+            };
+            view: {
+                type: string;
+                enum: string[];
+                description: string;
+                default: string;
+            };
+            sampleLimit?: undefined;
+            operation?: undefined;
+            property?: undefined;
+            groupBy?: undefined;
+            code?: undefined;
+            precision?: undefined;
+            action?: undefined;
+            match?: undefined;
+            confirmationMessage?: undefined;
+        };
+        required: never[];
+        additionalProperties: boolean;
+    };
+} | {
+    name: string;
+    description: string;
+    executionMode: string;
+    chatComponent: string;
+    parameters: {
+        type: string;
+        properties: {
+            startDate: {
+                type: string;
+                format: string;
+                description: string;
+            };
+            endDate: {
+                type: string;
+                format: string;
+                description: string;
+            };
+            dateProperty: {
+                type: string;
+                description: string;
+            };
+            useDefaultDateRange: {
+                type: string;
+                description: string;
+                default: boolean;
+            };
+            filters: {
+                type: string;
+                description: string;
+                default: never[];
+                items: {
+                    type: string;
+                    properties: {
+                        property: {
+                            type: string;
+                            description: string;
+                        };
+                        operator: {
+                            type: string;
+                            enum: string[];
+                            description: string;
+                        };
+                        value: {
+                            description: string;
+                            anyOf: {
+                                type: string;
+                            }[];
+                        };
+                        values: {
+                            type: string;
+                            description: string;
+                            items: {
+                                anyOf: {
+                                    type: string;
+                                }[];
+                            };
+                        };
+                    };
+                    required: string[];
+                    additionalProperties: boolean;
+                };
+            };
+            operation: {
+                type: string;
+                enum: string[];
+                description: string;
+            };
+            property: {
+                type: string;
+                description: string;
+            };
+            groupBy: {
+                type: string;
+                description: string;
+            };
+            code: {
+                type: string;
+                description: string;
+            };
+            title: {
+                type: string;
+                description: string;
+            };
+            precision: {
+                type: string;
+                description: string;
+                default: number;
+                minimum: number;
+                maximum: number;
+            };
+            view: {
+                type: string;
+                enum: string[];
+                description: string;
+                default: string;
+            };
+            sampleLimit?: undefined;
+            sortBy?: undefined;
+            sortDirection?: undefined;
+            columns?: undefined;
+            limit?: undefined;
+            action?: undefined;
+            match?: undefined;
+            confirmationMessage?: undefined;
+        };
+        required: string[];
+        additionalProperties: boolean;
+    };
+} | {
+    name: string;
+    description: string;
+    executionMode: string;
+    chatComponent: string;
+    parameters: {
+        type: string;
+        properties: {
+            action: {
+                type: string;
+                description: string;
+            };
+            match: {
+                type: string;
+                description: string;
+                minItems: number;
+                items: {
+                    type: string;
+                    properties: {
+                        property: {
+                            type: string;
+                            description: string;
+                        };
+                        value: {
+                            description: string;
+                            anyOf: {
+                                type: string;
+                            }[];
+                        };
+                    };
+                    required: string[];
+                    additionalProperties: boolean;
+                };
+            };
+            startDate: {
+                type: string;
+                format: string;
+                description: string;
+            };
+            endDate: {
+                type: string;
+                format: string;
+                description: string;
+            };
+            dateProperty: {
+                type: string;
+                description: string;
+            };
+            useDefaultDateRange: {
+                type: string;
+                description: string;
+                default: boolean;
+            };
+            confirmationMessage: {
+                type: string;
+                description: string;
+            };
+            sampleLimit?: undefined;
+            filters?: undefined;
+            sortBy?: undefined;
+            sortDirection?: undefined;
+            columns?: undefined;
+            limit?: undefined;
+            title?: undefined;
+            view?: undefined;
+            operation?: undefined;
+            property?: undefined;
+            groupBy?: undefined;
+            code?: undefined;
+            precision?: undefined;
+        };
+        required: string[];
+        additionalProperties: boolean;
+    };
+})[];

package/dist/src/table/types.d.ts

@@ -0,0 +1,79 @@
+export type TableColumnType = 'text' | 'number' | 'date' | 'datetime' | 'boolean' | 'URL' | 'email' | 'phone' | 'currency' | 'image' | 'array' | 'array-counter' | 'html';
+export interface TableColumn {
+    id?: string;
+    property: string;
+    label: string;
+    type: TableColumnType | string;
+    visible: boolean;
+    _remove?: boolean;
+    [key: string]: any;
+}
+export type TableFilterType = 'multi-select' | 'number-range' | 'number-comparison';
+export type TableFilterApplyMode = 'instant' | 'manual';
+export type NumberComparisonOperator = 'equals' | 'not-equals' | 'greater-than' | 'greater-than-or-equal' | 'less-than' | 'less-than-or-equal';
+export interface BaseTableFilter {
+    id?: string;
+    type: TableFilterType;
+    property: string;
+    label: string;
+    applyMode?: TableFilterApplyMode;
+}
+export interface MultiSelectFilterOption {
+    id: string;
+    value: string;
+    label: string;
+    checked: boolean;
+}
+export interface MultiSelectTableFilter extends BaseTableFilter {
+    type: 'multi-select';
+    options: MultiSelectFilterOption[];
+}
+export interface NumberRangeTableFilter extends BaseTableFilter {
+    type: 'number-range';
+    min?: number;
+    max?: number;
+    step?: number;
+    defaultMin?: number;
+    defaultMax?: number;
+    prefix?: string;
+    suffix?: string;
+    locale?: string;
+    showSlider?: boolean;
+    showInputs?: boolean;
+    showHistogram?: boolean;
+    histogramBins?: number;
+    allowOpenMin?: boolean;
+    allowOpenMax?: boolean;
+    inclusive?: boolean;
+}
+export interface NumberComparisonTableFilter extends BaseTableFilter {
+    type: 'number-comparison';
+    operators?: NumberComparisonOperator[];
+    defaultOperator?: NumberComparisonOperator;
+    defaultValue?: number | null;
+    step?: number;
+    prefix?: string;
+    suffix?: string;
+}
+export type NumberRangeFilter = NumberRangeTableFilter;
+export type NumberComparisonFilter = NumberComparisonTableFilter;
+export type TableFilter = MultiSelectTableFilter | NumberRangeTableFilter | NumberComparisonTableFilter;
+export interface NumberRangeFilterValue {
+    min: number | null;
+    max: number | null;
+}
+export interface NumberComparisonFilterValue {
+    operator: NumberComparisonOperator;
+    value: number;
+}
+export type TableFilterOperator = '==' | '!=' | '>' | '>=' | '<' | '<=' | 'contains' | 'startsWith' | 'endsWith' | 'in' | 'notIn' | 'isEmpty' | 'isNotEmpty';
+export interface TableToolFilter {
+    property: string;
+    operator: TableFilterOperator | string;
+    value?: any;
+    values?: any[];
+}
+export interface TableRowMatch {
+    property: string;
+    value: string | number | boolean | null;
+}

package/dist/tool-sandbox-DdkMLkDK.mjs

@@ -0,0 +1,182 @@
+import { s as p } from "./TableResultView.vue_vue_type_script_setup_true_lang-CBn-Oxl9.mjs";
+const E = 1500, S = 8 * 1024 * 1024, _ = 256 * 1024, g = 2e4, M = String.raw`
+'use strict';
+
+const nativePostMessage = self.postMessage.bind(self);
+const nativeStringify = JSON.stringify.bind(JSON);
+const nativeParse = JSON.parse.bind(JSON);
+const NativeWeakSet = WeakSet;
+const nativeEncoder = new TextEncoder();
+const nativeEncode = nativeEncoder.encode.bind(nativeEncoder);
+const arrayBufferByteLengthGetter = Object.getOwnPropertyDescriptor(ArrayBuffer.prototype, 'byteLength').get;
+const nativeBufferByteLength = Function.prototype.call.bind(arrayBufferByteLengthGetter);
+
+function encodedByteLength(value) {
+  return nativeBufferByteLength(nativeEncode(value).buffer);
+}
+
+function safeResult(value, maxBytes) {
+  const seen = new NativeWeakSet();
+  const serialized = nativeStringify(value, (key, nested) => {
+    if (key === '__proto__' || key === 'constructor' || key === 'prototype') return undefined;
+    if (typeof nested === 'bigint') return String(nested);
+    if (nested instanceof Date) return nested.toISOString();
+    if (nested && typeof nested === 'object') {
+      if (seen.has(nested)) return '[Circular]';
+      seen.add(nested);
+    }
+    return nested;
+  });
+  if (serialized === undefined) throw new Error('The calculation returned undefined or a non-serializable value.');
+  if (encodedByteLength(serialized) > maxBytes) {
+    throw new Error('The calculation result is too large. Return a smaller summary or fewer rows.');
+  }
+  return nativeParse(serialized);
+}
+
+self.onmessage = async event => {
+  const message = event.data || {};
+  if (message.type !== 'run' || typeof message.token !== 'string') return;
+  const token = message.token;
+
+  try {
+    for (const name of ['fetch', 'XMLHttpRequest', 'WebSocket', 'EventSource', 'importScripts', 'Worker', 'SharedWorker']) {
+      try {
+        Object.defineProperty(self, name, { value: undefined, writable: false, configurable: false });
+      } catch {}
+    }
+
+    const args = message.args && typeof message.args === 'object' ? message.args : {};
+    const keys = Object.keys(args);
+    if (!keys.every(key => /^[$A-Z_][0-9A-Z_$]*$/i.test(key) && !['constructor', 'prototype', '__proto__'].includes(key))) {
+      throw new Error('The calculation contains an invalid argument name.');
+    }
+
+    const calculate = Function(...keys, "'use strict';\n" + message.code);
+    const result = await Promise.resolve(calculate(...keys.map(key => args[key])));
+    nativePostMessage({
+      type: 'result',
+      token,
+      ok: true,
+      result: safeResult(result, message.maxOutputBytes),
+    });
+  } catch (error) {
+    nativePostMessage({
+      type: 'result',
+      token,
+      ok: false,
+      error: String(error && error.message ? error.message : error).slice(0, 500),
+    });
+  }
+};
+`, T = String.raw`
+'use strict';
+const workerSource = __WORKER_SOURCE__;
+
+window.addEventListener('message', event => {
+  const message = event.data || {};
+  if (event.source !== parent || message.type !== 'table-sandbox-run' || typeof message.token !== 'string') return;
+
+  const workerUrl = URL.createObjectURL(new Blob([workerSource], { type: 'text/javascript' }));
+  const worker = new Worker(workerUrl);
+  URL.revokeObjectURL(workerUrl);
+  let finished = false;
+
+  const finish = payload => {
+    if (finished) return;
+    finished = true;
+    clearTimeout(timer);
+    worker.terminate();
+    parent.postMessage({ type: 'table-sandbox-result', token: message.token, ...payload }, '*');
+  };
+
+  const timer = setTimeout(() => {
+    finish({ ok: false, error: 'The calculation timed out.' });
+  }, message.timeoutMs);
+
+  worker.onmessage = workerEvent => {
+    const response = workerEvent.data || {};
+    if (response.type !== 'result' || response.token !== message.token) return;
+    finish(response.ok
+      ? { ok: true, result: response.result }
+      : { ok: false, error: response.error || 'The calculation failed.' });
+  };
+
+  worker.onerror = () => finish({ ok: false, error: 'The isolated calculation worker failed.' });
+  worker.postMessage({
+    type: 'run',
+    token: message.token,
+    code: message.code,
+    args: message.args,
+    maxOutputBytes: message.maxOutputBytes,
+  });
+}, { passive: true });
+
+parent.postMessage({ type: 'table-sandbox-ready' }, '*');
+`.replace("__WORKER_SOURCE__", JSON.stringify(M));
+function x() {
+  return `<!doctype html><html><head><meta charset="utf-8"><meta http-equiv="Content-Security-Policy" content="default-src 'none'; script-src 'unsafe-inline' 'unsafe-eval' blob:; worker-src blob:; child-src blob:; connect-src 'none'; img-src 'none'; media-src 'none'; object-src 'none'; frame-src 'none'; style-src 'unsafe-inline'"></head><body><script>${T.replace(/<\/script/gi, "<\\/script")}<\/script></body></html>`;
+}
+function O() {
+  return typeof crypto < "u" && typeof crypto.randomUUID == "function" ? crypto.randomUUID() : `table-sandbox-${Date.now()}-${Math.random().toString(36).slice(2)}`;
+}
+function U(r, h = {}, s = {}) {
+  if (typeof document > "u" || !document.body)
+    return Promise.reject(new Error("Table calculations can only run in a browser session."));
+  if (typeof r != "string" || !r.trim())
+    return Promise.reject(new Error("No calculation code was provided."));
+  if (r.length > g)
+    return Promise.reject(new Error(`Calculation code is limited to ${g} characters.`));
+  const u = Math.min(Math.max(Math.trunc(s.timeoutMs ?? E), 100), 5e3), k = Math.min(Math.max(Math.trunc(s.maxInputBytes ?? S), 1024), 16 * 1024 * 1024), l = Math.min(Math.max(Math.trunc(s.maxOutputBytes ?? _), 1024), 1024 * 1024);
+  let d;
+  try {
+    d = p(h, k);
+  } catch (o) {
+    return Promise.reject(o);
+  }
+  return new Promise((o, a) => {
+    const e = document.createElement("iframe"), f = O();
+    let i = !1, m = !1;
+    e.setAttribute("sandbox", "allow-scripts"), e.setAttribute("aria-hidden", "true"), e.tabIndex = -1, e.style.position = "fixed", e.style.width = "0", e.style.height = "0", e.style.border = "0", e.style.opacity = "0", e.style.pointerEvents = "none", e.srcdoc = x();
+    const b = () => {
+      clearTimeout(v), window.removeEventListener("message", y), e.remove();
+    }, n = (t) => {
+      m || (m = !0, b(), t());
+    }, w = () => {
+      e.contentWindow?.postMessage({
+        type: "table-sandbox-run",
+        token: f,
+        code: r,
+        args: d,
+        timeoutMs: u,
+        maxOutputBytes: l
+      }, "*");
+    }, y = (t) => {
+      if (!(t.source !== e.contentWindow || !t.data || typeof t.data != "object")) {
+        if (t.data.type === "table-sandbox-ready") {
+          if (i) return;
+          i = !0, w();
+          return;
+        }
+        if (!(t.data.type !== "table-sandbox-result" || t.data.token !== f)) {
+          if (!t.data.ok) {
+            n(() => a(new Error(t.data.error || "The isolated calculation failed.")));
+            return;
+          }
+          try {
+            const c = p(t.data.result, l);
+            n(() => o(c));
+          } catch (c) {
+            n(() => a(c));
+          }
+        }
+      }
+    }, v = window.setTimeout(() => {
+      n(() => a(new Error(i ? "The calculation timed out." : "The isolated calculation environment could not start.")));
+    }, u + 1e3);
+    window.addEventListener("message", y), document.body.appendChild(e);
+  });
+}
+export {
+  U as r
+};