@emuanalytics/flow-rdf-core 4.0.4 → 4.0.6

package/dist/lib/context/context-registry.mjs

@@ -0,0 +1,63 @@
+import Debug from 'debug';
+import { deferred } from '../utils/deferred.mjs';
+import { FlowContext, DEFAULT_CONTEXT_ID } from './flow-context.mjs';
+
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+const debug = Debug("flow:context-registry");
+const _ContextRegistry = class _ContextRegistry {
+  constructor() {
+    __publicField(this, "_contexts", /* @__PURE__ */ new Map());
+  }
+  /**
+   * Initialize a new Flo.w context.
+   *
+   * @param options Context options.
+   */
+  initializeContext(options) {
+    options = { ..._ContextRegistry._defaultOptions, ...options };
+    debug(`Initializing context '${options.id}'`, options);
+    if (!this._contexts.get(options.id)) {
+      this._contexts.set(options.id, {
+        initialized: false,
+        deferred: deferred()
+      });
+    }
+    const registryEntry = this._contexts.get(options.id);
+    if (registryEntry.initialized) {
+      console.warn(`Context '${options.id}' has already been initialized. Skipping re-initialization.`);
+    }
+    const context = new FlowContext(options);
+    registryEntry.initialized = true;
+    registryEntry.deferred.resolve(context);
+    return context;
+  }
+  uninitializeContext(contextId = DEFAULT_CONTEXT_ID) {
+    if (!this._contexts.has(contextId)) {
+      console.warn(`Context '${contextId}' has not been initialized. Skipping uninitialization.`);
+    }
+    debug(`Uninitializing context '${contextId}'`);
+    this._contexts.delete(contextId);
+  }
+  getContext(id = DEFAULT_CONTEXT_ID) {
+    if (!this._contexts.get(id)) {
+      this._contexts.set(id, {
+        initialized: false,
+        deferred: deferred()
+      });
+    }
+    const deferredContext = this._contexts.get(id);
+    return deferredContext?.deferred;
+  }
+};
+__publicField(_ContextRegistry, "_defaultOptions", {
+  id: DEFAULT_CONTEXT_ID,
+  host: "https://flow.emu-analytics.net"
+});
+let ContextRegistry = _ContextRegistry;
+
+export { ContextRegistry };

package/dist/lib/context/debugger.mjs

@@ -0,0 +1,240 @@
+import * as mobx from 'mobx';
+import { isObservable, isComputed, isObservableArray, isObservableSet, isObservableMap } from 'mobx';
+import { isUndefined } from '../utils/type-checks.mjs';
+
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+const FLOW_GLOBAL = "FDBG";
+const CONSOLE_HIGHLIGHT_STYLE = `
+  padding: 2px 4px;
+  border-radius: 2px;
+  background: #389DFF;
+  color: white;`;
+const CONSOLE_BOLD_STYLE = `font-weight: bold;`;
+class Debugger {
+  /**
+   * Constructs a new Flo.w debugger instance.
+   *
+   * A new Flo.w debugger will be created automatically if the `enableDebug` option is
+   * specified when initializing a Flo.w context.
+   *
+   * @param context Flo.w context ID.
+   */
+  constructor(context) {
+    this.context = context;
+    __publicField(this, "spyDisposer");
+    __publicField(this, "watchDisposers", {});
+  }
+  /**
+   * Install a 'watch' for the specified context state property path.
+   *
+   * @param path Context state property path.
+   */
+  watch(path) {
+    if (!this.watchDisposers[path]) {
+      this.watchDisposers[path] = this.context.state.autorun(() => this.logStateValue(path));
+    }
+  }
+  /**
+   * Remove a  previously-installed 'watch' for the specified context state property path.
+   *
+   * @param path Context state property path.
+   */
+  unwatch(path) {
+    if (path) {
+      if (this.watchDisposers[path]) {
+        this.watchDisposers[path]();
+        delete this.watchDisposers[path];
+      }
+    } else {
+      Object.keys(this.watchDisposers).forEach((key) => this.watchDisposers[key]());
+      this.watchDisposers = {};
+    }
+  }
+  /**
+   * Set a Flo.w context state property.
+   *
+   * @param path Context state property path
+   * @param value New value to set
+   */
+  set(path, value) {
+    this.context.state.set(path, value);
+  }
+  /**
+   * Read the value of a Flo.w context state property.
+   *
+   * @param keyOrPath Context state property path.
+   * @returns The context state property value.
+   */
+  get(keyOrPath) {
+    if (isUndefined(keyOrPath)) {
+      keyOrPath = [];
+    } else if (typeof keyOrPath === "string") {
+      if (keyOrPath.startsWith("$")) {
+        keyOrPath = keyOrPath.slice(1);
+      }
+      return this.get(keyOrPath.split("."));
+    }
+    let value = this.context.state;
+    const path = [...keyOrPath];
+    while (path.length > 0) {
+      if (value == null) {
+        value = void 0;
+        break;
+      }
+      const key = path.shift();
+      value = value[key];
+    }
+    return toJSHelper(value, {});
+  }
+  /**
+   * Enable verbose debugging of all reactive updates.
+   */
+  spy() {
+    this.unspy();
+    this.spyDisposer = mobx.spy(this.spyListener.bind(this));
+  }
+  /**
+   * Disable verbose debugging of all reactive updates.
+   */
+  unspy() {
+    if (this.spyDisposer) {
+      this.spyDisposer();
+      this.spyDisposer = void 0;
+    }
+  }
+  /**
+   * Get a registered map instance by ID.
+   */
+  maps(mapId) {
+    if (!mapId) {
+      return Array.from(this.context.maps._maps.keys());
+    }
+    const mapPromise = this.context.maps.getMap(mapId);
+    return mapPromise?.value;
+  }
+  /**
+   * Get a registered reactive query by ID.
+   */
+  queries(queryId) {
+    if (!queryId) {
+      return Array.from(this.context.queries._queries.keys());
+    }
+    const queryPromise = this.context.queries.getQuery(queryId);
+    return queryPromise?.value;
+  }
+  spyListener(event) {
+    console.log(`%cspy`, CONSOLE_HIGHLIGHT_STYLE, event);
+  }
+  logStateValue(path) {
+    const value = toJSHelper(this.context.state.get(path), { recurseEverything: false });
+    console.log(`%cwatch%c %s`, CONSOLE_HIGHLIGHT_STYLE, CONSOLE_BOLD_STYLE, path, value);
+  }
+}
+function installGlobalDebugger(dbg) {
+  console.log(
+    `%cFlow.w RDF Debbugger`,
+    CONSOLE_HIGHLIGHT_STYLE,
+    `Enabled for context '${dbg.context.id}' - access using ${FLOW_GLOBAL} in web developer console.`
+  );
+  const g = typeof global !== "undefined" ? global : window;
+  g[FLOW_GLOBAL] = g[FLOW_GLOBAL] || {
+    context: dbg.context,
+    watch: dbg.watch.bind(dbg),
+    unwatch: dbg.unwatch.bind(dbg),
+    set: dbg.set.bind(dbg),
+    get: dbg.get.bind(dbg),
+    spy: dbg.spy.bind(dbg),
+    maps: dbg.maps.bind(dbg),
+    queries: dbg.queries.bind(dbg),
+    unspy: dbg.unspy.bind(dbg)
+  };
+}
+function cache(map, key, value, options) {
+  if (options.detectCycles)
+    map.set(key, value);
+  return value;
+}
+function getPlainObjectKeys(object) {
+  const enumerables = /* @__PURE__ */ new Set();
+  for (const key in object)
+    enumerables.add(key);
+  Object.getOwnPropertySymbols(object).forEach(function(k) {
+    if (Object.getOwnPropertyDescriptor(object, k).enumerable)
+      enumerables.add(k);
+  });
+  return Array.from(enumerables);
+}
+function toJSHelper(source, options, __alreadySeen = null) {
+  if (!options.recurseEverything && !isObservable(source))
+    return source;
+  if (typeof source !== "object")
+    return source;
+  if (source === null)
+    return null;
+  if (source instanceof Date)
+    return source;
+  if (isComputed(source)) {
+    try {
+      const value = source.get();
+      return { computedValue: value };
+    } catch (e) {
+      return { computedValueException: e.message };
+    }
+  }
+  const detectCycles = options.detectCycles === true;
+  if (detectCycles && source !== null && __alreadySeen.has(source)) {
+    return __alreadySeen.get(source);
+  }
+  if (isObservableArray(source) || Array.isArray(source)) {
+    const res_1 = cache(__alreadySeen, source, [], options);
+    const toAdd = source.map(function(value) {
+      return toJSHelper(value, options, __alreadySeen);
+    });
+    res_1.length = toAdd.length;
+    for (let i = 0, l = toAdd.length; i < l; i++)
+      res_1[i] = toAdd[i];
+    return res_1;
+  }
+  if (isObservableSet(source) || Object.getPrototypeOf(source) === Set.prototype) {
+    if (options.exportMapsAsObjects === false) {
+      const res_2 = cache(__alreadySeen, source, /* @__PURE__ */ new Set(), options);
+      source.forEach(function(value) {
+        res_2.add(toJSHelper(value, options, __alreadySeen));
+      });
+      return res_2;
+    } else {
+      const res_3 = cache(__alreadySeen, source, [], options);
+      source.forEach(function(value) {
+        res_3.push(toJSHelper(value, options, __alreadySeen));
+      });
+      return res_3;
+    }
+  }
+  if (isObservableMap(source) || Object.getPrototypeOf(source) === Map.prototype) {
+    if (options.exportMapsAsObjects === false) {
+      const res_4 = cache(__alreadySeen, source, /* @__PURE__ */ new Map(), options);
+      source.forEach(function(value, key) {
+        res_4.set(key, toJSHelper(value, options, __alreadySeen));
+      });
+      return res_4;
+    } else {
+      const res_5 = cache(__alreadySeen, source, {}, options);
+      source.forEach(function(value, key) {
+        res_5[key] = toJSHelper(value, options, __alreadySeen);
+      });
+      return res_5;
+    }
+  }
+  const res = cache(__alreadySeen, source, {}, options);
+  getPlainObjectKeys(source).forEach(function(key) {
+    res[key] = toJSHelper(source[key], options, __alreadySeen);
+  });
+  return res;
+}
+
+export { Debugger, installGlobalDebugger };

package/dist/lib/context/flow-context.mjs

@@ -0,0 +1,61 @@
+import { Client } from '@emuanalytics/flow-engine-client';
+import { Debugger, installGlobalDebugger } from './debugger.mjs';
+import { MapRegistry } from './map-registry.mjs';
+import { QueryRegistry } from './query-registry.mjs';
+import { ReactiveExpression } from '../expressions/reactive-expression.mjs';
+
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+const DEFAULT_FLOW_HOST = "https://flow.emu-analytics.net";
+const DEFAULT_CONTEXT_ID = "default";
+const _FlowContext = class _FlowContext {
+  /**
+   * Constructs a new `FlowCoreContext`.
+   *
+   * Use [[ContextRegistry.initializeContext]] to create an instance of `FlowCoreContext`.
+   *
+   * @param options - The context options.
+   */
+  constructor(options) {
+    __publicField(this, "_options");
+    __publicField(this, "flowClient");
+    __publicField(this, "state");
+    __publicField(this, "maps", new MapRegistry());
+    __publicField(this, "queries", new QueryRegistry());
+    /** The Flo.w debugger. Available as `window.FDBG` in the browser's web developer console. */
+    __publicField(this, "debugger");
+    this._options = {
+      ..._FlowContext._defaultOptions,
+      ...options
+    };
+    if (!options.state.initialized) {
+      options.state.initialize();
+    }
+    this.flowClient = new Client(this._options.host, this._options.apiKey);
+    this.state = options.state;
+    if (options.enableDebug) {
+      this.debugger = new Debugger(this);
+      installGlobalDebugger(this.debugger);
+    }
+  }
+  get id() {
+    return this._options.id;
+  }
+  evaluateExpression(expr) {
+    const expression = new ReactiveExpression(expr);
+    expression.bindState(this.state);
+    return expression.value;
+  }
+};
+__publicField(_FlowContext, "_defaultOptions", {
+  id: DEFAULT_CONTEXT_ID,
+  host: DEFAULT_FLOW_HOST,
+  enableDebug: false
+});
+let FlowContext = _FlowContext;
+
+export { DEFAULT_CONTEXT_ID, FlowContext };

package/dist/lib/context/global-state.mjs

@@ -0,0 +1,70 @@
+import announce from '../utils/announce.mjs';
+import { getGlobal } from '../utils/global.mjs';
+import { ContextRegistry } from './context-registry.mjs';
+import { configure } from 'mobx';
+
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+class FlowRdfCoreGlobals {
+  constructor() {
+    /**
+     * FlowRdfCoreGlobals version.
+     * Compatiblity with other versions loaded in memory as long as this version matches.
+     * It indicates that the global state still stores similar information
+     *
+     * N.B: this version is unrelated to the package version.
+     */
+    __publicField(this, "version", 1);
+    __publicField(this, "globalContextRegistry", new ContextRegistry());
+  }
+}
+let canMergeGlobalState = true;
+let isolateCalled = false;
+let globalState = function() {
+  const global = getGlobal();
+  if (global.__flowRdfCoreInstanceCount > 0 && !global.__flowRdfCoreGlobals) {
+    canMergeGlobalState = false;
+  }
+  if (global.__flowRdfCoreGlobals && global.__flowRdfCoreGlobals.version !== new FlowRdfCoreGlobals().version) {
+    canMergeGlobalState = false;
+  }
+  if (!canMergeGlobalState) {
+    setTimeout(() => {
+      if (!isolateCalled) {
+        throw new Error(
+          'There are multiple, different versions of FlowRdfCore active. Make sure FlowRdfCore is loaded only once or use `configure({ isolateGlobalState: true })`",'
+        );
+      }
+    }, 1);
+    return new FlowRdfCoreGlobals();
+  } else if (global.__flowRdfCoreGlobals) {
+    global.__flowRdfCoreInstanceCount += 1;
+    return global.__flowRdfCoreGlobals;
+  } else {
+    global.__flowRdfCoreInstanceCount = 1;
+    configure({
+      enforceActions: "never"
+    });
+    announce();
+    return global.__flowRdfCoreGlobals = new FlowRdfCoreGlobals();
+  }
+}();
+function isolateGlobalState() {
+  isolateCalled = true;
+  if (canMergeGlobalState) {
+    const global = getGlobal();
+    if (--global.__flowRdfCoreInstanceCount === 0) {
+      global.__flowRdfCoreGlobals = void 0;
+    }
+    globalState = new FlowRdfCoreGlobals();
+  }
+}
+function getGlobalState() {
+  return globalState;
+}
+
+export { FlowRdfCoreGlobals, getGlobalState, isolateGlobalState };

package/dist/lib/context/map-registry.mjs

@@ -0,0 +1,59 @@
+import Debug from 'debug';
+import { deferred } from '../utils/deferred.mjs';
+
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+const debug = Debug("flow:map-registry");
+class MapRegistry {
+  constructor() {
+    __publicField(this, "_maps", /* @__PURE__ */ new Map());
+  }
+  /**
+   * Register a Flo.w map.
+   *
+   * @param map Map to register.
+   */
+  registerMap(map) {
+    debug(`Registering map '${map.id}'`);
+    if (!this._maps.get(map.id)) {
+      this._maps.set(map.id, deferred());
+    }
+    const deferredMap = this._maps.get(map.id);
+    deferredMap.resolve(map);
+    return map;
+  }
+  /**
+   * Un-register a Flo.w map.
+   *
+   * ```mermaid
+   * graph TB
+   *   mermaid.js --> TypeDoc;
+   * ```
+   *
+   * @param map - the map to unregister.
+   */
+  unregisterMap(map) {
+    debug(`Unregistering map '${map.id}'`);
+    this._maps.delete(map.id);
+  }
+  /**
+   * Retrieve the specified map.
+   *
+   * This method returns a promise that resolves when the map has been initialized.
+   *
+   * @param id Map ID.
+   */
+  getMap(id) {
+    if (!this._maps.get(id)) {
+      this._maps.set(id, deferred());
+    }
+    const deferredMap = this._maps.get(id);
+    return deferredMap;
+  }
+}
+
+export { MapRegistry };

package/dist/lib/context/query-registry.mjs

@@ -0,0 +1,53 @@
+import Debug from 'debug';
+import { deferred } from '../utils/deferred.mjs';
+
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+const debug = Debug("flow:query-registry");
+class QueryRegistry {
+  constructor() {
+    __publicField(this, "_queries", /* @__PURE__ */ new Map());
+  }
+  /**
+   * Register a Flo.w reactive query.
+   *
+   * @param query Query to register.
+   */
+  registerQuery(query) {
+    debug(`Registering query '${query.id}'`);
+    if (!this._queries.get(query.id)) {
+      this._queries.set(query.id, deferred());
+    }
+    const deferredQuery = this._queries.get(query.id);
+    deferredQuery.resolve(query);
+  }
+  /**
+   * Un-register a Flo.w reactive query.
+   *
+   * @param query Query to unregister.
+   */
+  unregisterQuery(query) {
+    debug(`Unregistering map '${query.id}'`);
+    this._queries.delete(query.id);
+  }
+  /**
+   * Retrieve the specified query.
+   *
+   * This method returns a promise that resolves when the query has been initialized.
+   *
+   * @param id Map ID.
+   */
+  getQuery(id) {
+    if (!this._queries.get(id)) {
+      this._queries.set(id, deferred());
+    }
+    const deferredQuery = this._queries.get(id);
+    return deferredQuery;
+  }
+}
+
+export { QueryRegistry };

package/dist/lib/errors/flow-error.mjs

@@ -0,0 +1,10 @@
+class FlowCoreError extends Error {
+  constructor(message, cause) {
+    super(message);
+    this.cause = cause;
+    this.name = this.constructor.name;
+    this.cause = cause;
+  }
+}
+
+export { FlowCoreError };

package/dist/lib/errors/flow-expression-error.mjs

@@ -0,0 +1,14 @@
+import { FlowCoreError } from './flow-error.mjs';
+
+class FlowCoreExpressionError extends FlowCoreError {
+  constructor(expression, reason, errors) {
+    super(`Failed to evaluate expression:
+${expression}
+------
+${errors.join(", ")}`);
+    this.reason = reason;
+    this.errors = errors;
+  }
+}
+
+export { FlowCoreExpressionError };

package/dist/lib/errors/flow-map-error.mjs

@@ -0,0 +1,9 @@
+import { FlowCoreError } from './flow-error.mjs';
+
+class FlowMapError extends FlowCoreError {
+  constructor(message, originalError) {
+    super(message, originalError);
+  }
+}
+
+export { FlowMapError };