@miso.ai/client-sdk-ui 1.11.4-beta.1 → 1.11.4-beta.3

package/src/workflow/options/api.js

@@ -0,0 +1,46 @@
+import { trimObj } from '@miso.ai/commons';
+import { mergeOptions } from './utils.js';
+
+export function normalizeApiOptions([name, payload] = []) {
+  // TODO: take object form as well
+  if (name === false) {
+    return { actor: false };
+  }
+  if (typeof name === 'object' && payload === undefined) {
+    payload = name;
+    name = undefined;
+  }
+  let group = undefined;
+  if (name && name.indexOf('/') !== -1) {
+    [group, name] = name.split('/');
+  }
+  if ((name && typeof name !== 'string') || (payload !== undefined && typeof payload !== 'object')) {
+    throw new Error(`Invalid arguments for useApi(): ${name}, ${payload}`);
+  }
+  return trimObj({ group, name, payload });
+}
+
+export function mergeApiOptions(...optionsList) {
+  if (optionsList[optionsList.length - 1] === false) {
+    return false;
+  }
+  return mergeOptions(optionsList, (merged, options) => Object.assign(merged, {
+    ...options,
+    payload: mergeApiPayloads(merged.payload, options.payload),
+  }));
+}
+
+function mergeApiPayloads(base, overrides) {
+  return {
+    ...base,
+    ...overrides,
+    ...mergeObjectValueIfPresent('_meta', base, overrides),
+  };
+}
+
+function mergeObjectValueIfPresent(key, base, overrides) {
+  const baseValue = base && base[key];
+  const overridesValue = overrides && overrides[key];
+  const value = baseValue ? (overridesValue ? { ...baseValue, ...overridesValue } : baseValue) : overridesValue;
+  return value !== undefined ? { [key]: value } : {};
+}

package/src/workflow/options/configurable.js

@@ -0,0 +1,48 @@
+import { WORKFLOW_CONFIGURABLE } from '../../constants.js';
+
+const DEFAULT_FEATURES = [
+  WORKFLOW_CONFIGURABLE.API,
+  WORKFLOW_CONFIGURABLE.LAYOUTS,
+  WORKFLOW_CONFIGURABLE.DATA_PROCESSOR,
+  WORKFLOW_CONFIGURABLE.TRACKERS,
+  WORKFLOW_CONFIGURABLE.INTERACTIONS,
+];
+
+export function makeConfigurable(prototype, features = DEFAULT_FEATURES) {
+  for (const feature of features) {
+    injectConfigurableFeature(prototype, feature);
+  }
+}
+
+function injectConfigurableFeature(prototype, feature) {
+  if (feature === 'api') {
+    Object.assign(prototype, {
+      useApi(...args) {
+        this._options.api.merge(args);
+        return this;
+      },
+      clearApi() {
+        this._options.api.set();
+        return this;
+      },
+    });
+  } else {
+    const upperCased = upperCase(feature);
+    Object.assign(prototype, {
+      [`use${upperCased}`](value) {
+        (this._options[feature]).merge(value);
+        return this;
+      },
+      [`clear${upperCased}`]() {
+        (this._options[feature]).set();
+        return this;
+      },
+    });
+  }
+}
+
+// helpers //
+// TODO: move to commons
+function upperCase(str) {
+  return str.charAt(0).toUpperCase() + str.slice(1);
+}

package/src/workflow/options/data-processor.js

@@ -0,0 +1,15 @@
+import { asArray } from '@miso.ai/commons';
+
+export function normalizeDataProcessorOptions(fns) {
+  fns = asArray(fns);
+  for (const fn of fns) {
+    if (typeof fn !== 'function') {
+      throw new Error(`Expect data processor options to be a function: ${fn}`);
+    }
+  }
+  return fns;
+}
+
+export function mergeDataProcessorOptions(...optionsList) {
+  return optionsList.flat().filter(Boolean);
+}

package/src/workflow/options/filters.js

@@ -0,0 +1,10 @@
+import { mergeOptions, normalizeOptions } from './utils.js';
+
+export const normalizeFiltersOptions = normalizeOptions;
+
+export function mergeFiltersOptions(...optionsList) {
+  if (optionsList[optionsList.length - 1] === false) {
+    return false;
+  }
+  return mergeOptions(optionsList, (merged, options) => Object.assign(merged, options));
+}

package/src/workflow/options/index.js

@@ -0,0 +1,10 @@
+export * from './roles.js';
+export * from './api.js';
+export * from './layouts.js';
+export * from './data-processor.js';
+export * from './trackers.js';
+export * from './interactions.js';
+export * from './filters.js';
+export * from './pagination.js';
+export * from './options.js';
+export * from './configurable.js';

package/src/workflow/options/interactions.js

@@ -0,0 +1,36 @@
+import { asArray } from '@miso.ai/commons';
+import { mergeOptions, concatArrays } from './utils.js';
+
+export function normalizeInteractionsOptions(options) {
+  if (options === undefined) {
+    return undefined;
+  }
+  if (options === false) {
+    return {
+      handle: () => {},
+    };
+  }
+  // preprocess
+  const preprocess = asArray(options.preprocess);
+  for (const p of preprocess) {
+    if (typeof p !== 'function') {
+      throw new Error(`Expect preprocess options to be a function: ${p}`);
+    }
+  }
+  // handle
+  if (options.handle && typeof options.handle !== 'function') {
+    throw new Error(`Expect handle options to be a function: ${options.handle}`);
+  }
+  return { ...options, preprocess };
+}
+
+export function mergeInteractionsOptions(...optionsList) {
+  if (optionsList[optionsList.length - 1] === false) {
+    return false;
+  }
+  return mergeOptions(optionsList, (merged, options) => Object.assign(merged, {
+    ...options,
+    preprocess: concatArrays(merged.preprocess, options.preprocess),
+  }));
+}
+

package/src/workflow/options/layouts.js

@@ -0,0 +1,73 @@
+import { asArray, lowerCamelToSnake, kebabToSnake } from '@miso.ai/commons';
+import { ROLE } from '../../constants.js';
+import { mergeOptions } from './utils.js';
+
+export function normalizeLayoutsOptions(options = {}) {
+  if (options === false) {
+    return false;
+  }
+  // fallback: results -> products
+  const { results, ...rest } = options;
+  if (results !== undefined) {
+    console.warn(`useLayouts({ results: ... }) is deprecated, use useLayouts({ ${ROLE.PRODUCTS}: ... }) instead`);
+    options = { ...rest, [ROLE.PRODUCTS]: results };
+  }
+  const normalize = {};
+  for (const [role, args] of Object.entries(options)) {
+    normalize[normalizeRole(role)] = normalizeLayoutOptions(args);
+  }
+  return normalize;
+}
+
+function normalizeRole(role) {
+  role = lowerCamelToSnake(role);
+  role = kebabToSnake(role);
+  return role;
+}
+
+function normalizeLayoutOptions(args) {
+  // take args:
+  // * undefined
+  // * false
+  // * name (string)
+  // * options (object)
+  // * [name, options]
+  if (args === undefined) {
+    return undefined;
+  }
+  let [name, options] = asArray(args);
+  if (typeof name === 'object') {
+    options = name;
+    name = undefined;
+  }
+  return [name, options];
+}
+
+export function mergeLayoutsOptions(...optionsList) {
+  if (optionsList[optionsList.length - 1] === false) {
+    return false;
+  }
+  return mergeOptions(optionsList, (merged, options) => {
+    for (const [role, args] of Object.entries(options)) {
+      merged[role] = mergeLayoutOptions(merged[role], args);
+    }
+    return merged;
+  });
+}
+
+function mergeLayoutOptions(base, overrides) {
+  overrides = normalizeLayoutOptions(overrides);
+  if (overrides[0] === false) {
+    return overrides;
+  }
+  return base && overrides ? [overrides[0] || base[0], mergeLayoutParameters(base[1], overrides[1])] : (overrides || base);
+}
+
+function mergeLayoutParameters(base, overrides) {
+  return {
+    ...base,
+    ...overrides,
+    link: { ...(base && base.link), ...(overrides && overrides.link) },
+    templates: { ...(base && base.templates), ...(overrides && overrides.templates) },
+  };
+}

package/src/workflow/options/options.js

@@ -0,0 +1,169 @@
+import { EventEmitter, defineValues } from '@miso.ai/commons';
+import { WORKFLOW_CONFIGURABLE } from '../../constants.js';
+import { normalizeApiOptions, mergeApiOptions } from './api.js';
+import { normalizeLayoutsOptions, mergeLayoutsOptions } from './layouts.js';
+import { normalizeDataProcessorOptions, mergeDataProcessorOptions } from './data-processor.js';
+import { normalizeTrackersOptions, mergeTrackersOptions } from './trackers.js';
+import { normalizeInteractionsOptions, mergeInteractionsOptions } from './interactions.js';
+import { normalizeFiltersOptions, mergeFiltersOptions } from './filters.js';
+import { normalizePaginationOptions, mergePaginationOptions } from './pagination.js';
+
+const FEATURES = [
+  {
+    key: WORKFLOW_CONFIGURABLE.API,
+    normalize: normalizeApiOptions,
+    merge: mergeApiOptions,
+  },
+  {
+    key: WORKFLOW_CONFIGURABLE.LAYOUTS,
+    normalize: normalizeLayoutsOptions,
+    merge: mergeLayoutsOptions,
+  },
+  {
+    key: WORKFLOW_CONFIGURABLE.DATA_PROCESSOR,
+    normalize: normalizeDataProcessorOptions,
+    merge: mergeDataProcessorOptions,
+  },
+  {
+    key: WORKFLOW_CONFIGURABLE.TRACKERS,
+    normalize: normalizeTrackersOptions,
+    merge: mergeTrackersOptions,
+  },
+  {
+    key: WORKFLOW_CONFIGURABLE.INTERACTIONS,
+    normalize: normalizeInteractionsOptions,
+    merge: mergeInteractionsOptions,
+  },
+  {
+    key: WORKFLOW_CONFIGURABLE.FILTERS,
+    normalize: normalizeFiltersOptions,
+    merge: mergeFiltersOptions,
+  },
+  {
+    key: WORKFLOW_CONFIGURABLE.PAGINATION,
+    normalize: normalizePaginationOptions,
+    merge: mergePaginationOptions,
+  },
+];
+
+
+
+export class WorkflowContextOptions {
+
+  constructor() {
+    this._events = new EventEmitter({ target: this });
+    this._globals = {};
+  }
+
+  _notify(name) {
+    this._events.emit(name);
+    this._events.emit('_update', name);
+  }
+
+}
+
+export class WorkflowOptions {
+
+  constructor(context = {}, defaults = {}) {
+    this._events = new EventEmitter({ target: this });
+    this._defaults = defaults; // TODO: we should call normalize() on defaults
+    this._context = context || {};
+    this._locals = {};
+
+    defineValues(this, {
+      resolved: new ResolvedWorkflowOptions(this),
+      defaults,
+    });
+
+    if (context && context.on) {
+      this._unsubscribes = [
+        context.on('_update', name => this._notify(name)),
+      ];
+    }
+  }
+
+  _notify(name) {
+    this.resolved._invalidate(name);
+    this._events.emit(name);
+  }
+
+  _destroy() {
+    for (const unsubscribe of this._unsubscribes || []) {
+      unsubscribe();
+    }
+    this._unsubscribes = [];
+  }
+
+}
+
+class ResolvedWorkflowOptions {
+
+  constructor(options) {
+    this._options = options;
+    this._cache = {};
+  }
+
+  _invalidate(key) {
+    this._cache[key] = undefined;
+  }
+
+  _get({ key, merge }) {
+    if (this._cache[key] === undefined) {
+      const options = this._options;
+      const contextFeature = options._context[key];
+      this._cache[key] = merge(options._defaults[key], contextFeature && contextFeature.get(), options._locals[key]);
+    }
+    return this._cache[key];
+  }
+
+}
+
+class WorkflowConfigurableFeature {
+
+  constructor(options, store, key, normalize, merge) {
+    this._options = options;
+    this._store = store;
+    this._key = key;
+    this._normalize = value => value !== undefined ? normalize(value) : undefined;
+    this._merge = merge;
+  }
+
+  get() {
+    return this._store[this._key];
+  }
+
+  set(value) {
+    this._set(this._normalize(value));
+  }
+
+  merge(value) {
+    this._set(this._merge(this.get(), this._normalize(value)));
+  }
+
+  _set(value) {
+    this._store[this._key] = value;
+    this._options._notify(this._key);
+  }
+
+}
+
+for (const feature of FEATURES) {
+  const { key, normalize, merge } = feature;
+  Object.defineProperty(WorkflowContextOptions.prototype, key, {
+    get: function() {
+      const _key = `_${key}`;
+      return this[_key] || (this[_key] = new WorkflowConfigurableFeature(this, this._globals, key, normalize, merge));
+    },
+  });
+  Object.defineProperty(WorkflowOptions.prototype, key, {
+    get: function() {
+      const _key = `_${key}`;
+      return this[_key] || (this[_key] = new WorkflowConfigurableFeature(this, this._locals, key, normalize, merge));
+    },
+  });
+  Object.defineProperty(ResolvedWorkflowOptions.prototype, key, {
+    get: function() {
+      return this._get(feature);
+    },
+  });
+}

package/src/workflow/options/pagination.js

@@ -0,0 +1,18 @@
+import { mergeOptions } from './utils.js';
+
+export function normalizePaginationOptions(options) {
+  if (options === undefined) {
+    throw new Error(`Expect pagination options to be an object or a boolean value: ${options}`);
+  }
+  if (typeof options === 'boolean') {
+    options = { active: options };
+  }
+  return options;
+}
+
+export function mergePaginationOptions(...optionsList) {
+  if (optionsList[optionsList.length - 1] === false) {
+    return false;
+  }
+  return mergeOptions(optionsList, (merged, options) => Object.assign(merged, options));
+}

package/src/workflow/options/roles.js

@@ -0,0 +1,12 @@
+export function mergeRolesOptions(base, overrides) {
+  return Object.freeze({
+    ...base,
+    ...overrides,
+    members: mergeRolesMembers(base.members, overrides.members),
+    mappings: Object.freeze({ ...base.mappings, ...overrides.mappings }),
+  });
+}
+
+function mergeRolesMembers(base = [], overrides = []) {
+  return [...new Set([...base, ...overrides])];
+}

package/src/workflow/options/trackers.js

@@ -0,0 +1,32 @@
+import { mergeOptions } from './utils.js';
+
+export function normalizeTrackersOptions(options) {
+  if (options === undefined || options === false) {
+    return options;
+  }
+  const normalized = {};
+  for (const [role, args] of Object.entries(options)) {
+    normalized[role] = normalizeTrackerOptions(args);
+  }
+  return normalized;
+}
+
+function normalizeTrackerOptions(options) {
+  return options;
+}
+
+export function mergeTrackersOptions(...optionsList) {
+  if (optionsList[optionsList.length - 1] === false) {
+    return false;
+  }
+  return mergeOptions(optionsList, (merged, options) => Object.assign(merged, {
+    ...options,
+    impression: mergeTrackerEventOptions(merged.impression, options.impression),
+    viewable: mergeTrackerEventOptions(merged.viewable, options.viewable),
+    click: mergeTrackerEventOptions(merged.click, options.click),
+  }));
+}
+
+function mergeTrackerEventOptions(base = {}, overrides = {}) {
+  return (overrides === false || base === false) ? overrides : { ...base, ...overrides };
+}

package/src/workflow/options/utils.js

@@ -0,0 +1,26 @@
+import { trimObj } from '@miso.ai/commons';
+
+export function concatArrays(a0, a1) {
+  return (a0 && a0.length) ? (a1 && a1.length) ? [...a0, ...a1] : a0 : a1;
+}
+
+export function mergeOptions(optionsList, merge) {
+  let merged = {};
+  for (const options of optionsList) {
+    if (!options) {
+      continue;
+    }
+    merged = merge(merged, options);
+  }
+  return trimObj(merged);
+}
+
+export function normalizeOptions(options) {
+  if (options === undefined) {
+    throw new Error(`Expect options to be an object or a boolean value: ${options}`);
+  }
+  if (typeof options === 'boolean') {
+    options = { active: options };
+  }
+  return options;
+}

package/src/workflow/processors.js

@@ -1,5 +1,35 @@
 import { trimObj } from '@miso.ai/commons';
 import { STATUS, ROLE, EVENT_TYPE, isPerformanceEventType, isProductRole } from '../constants.js';
+import { fields } from '../actor/index.js';
+
+// role mappings //
+export function mappingSortData(_, { hub, workflowOptions = {} } = {}) {
+  const { sort: { options = [] } = {} } = workflowOptions.filters || {};
+  if (!options.length) {
+    return [];
+  }
+  const { sort } = hub.states[fields.filters()] || {};
+  const selectedField = (sort && sort.field) || findDefaultSortOption(options).field;
+  if (!selectedField) {
+    return options;
+  }
+  // mark selected
+  return options.map(option => {
+    return {
+      ...option,
+      selected: option.field === selectedField,
+    };
+  });
+}
+
+function findDefaultSortOption(options) {
+  for (const option of options) {
+    if (option.default) {
+      return option;
+    }
+  }
+  return options[0];
+}
 
 // data //
 export function getRevision(data) {
@@ -79,40 +109,6 @@ export function writeAnswerStageToMeta(data) {
   };
 }
 
-export function writeFiltersToPayload(payload = {}, filters) {
-  return trimObj({
-    ...payload,
-    ...composeFiltersPayload(filters),
-  });
-}
-
-function composeFiltersPayload(filters) {
-  if (!filters) {
-    return undefined;
-  }
-  const { facets } = filters;
-  return trimObj({
-    facet_filters: composeFacetFilters(facets),
-  });
-}
-
-function composeFacetFilters(facets) {
-  if (!facets) {
-    return undefined;
-  }
-  const filters = {};
-  for (const field in facets) {
-    const values = facets[field];
-    if (!values || !values.length) {
-      continue; // just in case
-    }
-    filters[field] = {
-      terms: values,
-    };
-  }
-  return Object.keys(filters).length ? filters : undefined;
-}
-
 export function retainFacetCountsInData(data, currentFacetCounts) {
   if (!currentFacetCounts) {
     return data;

package/src/workflow/recommendation.js

@@ -2,7 +2,7 @@ import { defineValues, API } from '@miso.ai/commons';
 import Workflow from './base.js';
 import { ListLayout } from '../layout/index.js';
 import { ROLE } from '../constants.js';
-import { mergeRolesOptions } from './options.js';
+import { mergeRolesOptions } from './options/index.js';
 import { mergeInteraction } from './processors.js';
 
 const DEFAULT_API_OPTIONS = Object.freeze({