@miso.ai/client-sdk-ui 1.13.2-beta.0 → 1.14.0-beta.2

package/src/workflow/asks.js

@@ -1,143 +0,0 @@
-import { WORKFLOW_CONFIGURABLE, STATUS } from '../constants.js';
-import WorkflowContext from './context.js';
-import Ask from './ask.js';
-import { makeConfigurable } from './options/index.js';
-import { makeAutocompletableContext } from './autocompletable.js';
-
-const DEFAULT_AUTO_NEXT_OPTIONS = { event: 'done' };
-
-function autoNextOptionsAsPredicate(options = DEFAULT_AUTO_NEXT_OPTIONS) {
-  if (options === true) {
-    options = DEFAULT_AUTO_NEXT_OPTIONS;
-  }
-  if (typeof options === 'string') {
-    options = { event: options };
-  }
-  switch (typeof options) {
-    case 'object':
-      // TODO: support more options
-      return event => event && options.event === event._event;
-    case 'function':
-      return options;
-    default:
-      return () => false;
-  }
-}
-
-export default class Asks extends WorkflowContext {
-
-  constructor(plugin, client) {
-    super('asks', plugin, client);
-    this._initAutocompleteContext(); // must be earlier than root workflow
-    this._byQid = new Map();
-    this._byPqid = new Map();
-    this._root = new Ask(this); // initialize with default workflow
-    client._events.emit('postworkflow', this._root);
-
-    this._events.on('*', event => this._createNextIfNecessary(event));
-    this._events.on('loading', event => this._setActive(event.workflow));
-    this._events.on('destroy', () => this._requestEmitAfterDestroy());
-    this._events.on('after-destroy', () => this._syncActiveOnAfterDestroy());
-    this._autoNextFn = undefined;
-    this._active = this._root;
-  }
-
-  get root() {
-    return this._root;
-  }
-
-  get workflows() {
-    return [this._root, ...this._byPqid.values()];
-  }
-
-  get active() {
-    return this._active;
-  }
-
-  getByQuestionId(questionId) {
-    if (typeof questionId !== 'string') {
-      throw new Error(`Required ID to be a string: ${questionId}`);
-    }
-    return this._byQid.get(questionId);
-  }
-
-  getByParentQuestionId(parentQuestionId, { autoCreate = false } = {}) {
-    if (parentQuestionId === undefined) {
-      return this._root;
-    }
-    if (typeof parentQuestionId !== 'string') {
-      throw new Error(`Required ID to be a string: ${parentQuestionId}`);
-    }
-    let workflow = this._byPqid.get(parentQuestionId);
-    if (!workflow && autoCreate) {
-      workflow = new Ask(this, parentQuestionId);
-      this._client._events.emit('postworkflow', workflow);
-    }
-    return workflow;
-  }
-
-  reset({ root = true, events, ...options } = {}) {
-    // clear event listeners on context
-    if (events === undefined) {
-      events = !!root; // events are default to be true only when root = true
-    }
-    if (events) {
-      this._events.clear();
-    }
-
-    // destroy all follow-up workflows
-    for (const workflow of this._byPqid.values()) {
-      workflow.destroy(options);
-    }
-
-    // reset root workflow
-    if (root) {
-      this._root.restart();
-    }
-  }
-
-  autoNext(options) {
-    this._autoNextFn = autoNextOptionsAsPredicate(options);
-  }
-
-  _createNextIfNecessary(event) {
-    if (!this._autoNextFn || !this._autoNextFn(event)) {
-      return;
-    }
-    const { workflow } = event;
-    workflow && workflow.getOrCreateNext();
-  }
-
-  _requestEmitAfterDestroy() {
-    if (this._emitAfterDestroyRequested) {
-      return;
-    }
-    this._emitAfterDestroyRequested = true;
-    setTimeout(() => {
-      this._emitAfterDestroyRequested = false;
-      this._events.emit('after-destroy', {});
-    }, 0);
-  }
-
-  _syncActiveOnAfterDestroy() {
-    if (!this._active.destroyed) {
-      return;
-    }
-    // find last non-initial workflow or root
-    let workflow = this._root;
-    for (; workflow.next && workflow.next.status !== STATUS.INITIAL; workflow = workflow.next) {}
-    this._setActive(workflow);
-  }
-
-  _setActive(workflow) {
-    if (workflow === this._active) {
-      return;
-    }
-    this._active = workflow;
-    this._events.emit('active', { workflow });
-  }
-
-}
-
-makeConfigurable(Asks.prototype, [WORKFLOW_CONFIGURABLE.TEMPLATES]);
-makeAutocompletableContext(Asks.prototype);

package/src/workflow/autocompletable.js

@@ -1,67 +0,0 @@
-import { mixin } from '@miso.ai/commons';
-import { fields } from '../actor/index.js';
-import Autocomplete from './autocomplete.js';
-
-export function makeAutocompletable(prototype) {
-  mixin(prototype, AutocompletableMixin.prototype);
-}
-
-export function makeAutocompletableContext(prototype) {
-  mixin(prototype, AutocompletableContextMixin.prototype);
-}
-
-export class AutocompletableMixin {
-
-  _initAutocomplete(args) {
-    this._autocomplete = new Autocomplete(this, { defaults: args.defaults.autocomplete });
-  }
-
-  get autocomplete() {
-    return this._autocomplete;
-  }
-
-  updateCompletions(data) {
-    this._hub.update(fields.completions(), data);
-    return this;
-  }
-
-  _destroyAutocomplete() {
-    this._autocomplete && this._autocomplete._destroy();
-    this._autocomplete = undefined;
-  }
-
-}
-
-export class AutocompletableContextMixin {
-
-  _initAutocompleteContext() {
-    this._autocomplete = new AutocompleteContext(this);
-  }
-
-  get autocomplete() {
-    return this._autocomplete;
-  }
-
-}
-
-class AutocompleteContext {
-
-  constructor(context) {
-    this._context = context;
-    this._active = false;
-  }
-
-  // API //
-  get enabled() {
-    return this._active;
-  }
-
-  enable() {
-    this._active = true;
-  }
-
-  disable() {
-    this._active = false;
-  }
-
-}

package/src/workflow/autocomplete.js

@@ -1,114 +0,0 @@
-import { STATUS } from '../constants.js';
-import { fields } from '../actor/index.js';
-import Workflow from './base.js';
-
-const ROLES_OPTIONS = Object.freeze({
-  members: [],
-});
-
-function shimDefaults({ layouts, trackers, ...options } = {}) {
-  return {
-    ...options,
-    layouts: {},
-    trackers: {},
-  };
-}
-
-function sameInputValue(a, b) {
-  return getInputValue(a) === getInputValue(b);
-}
-
-function getInputValue(args) {
-  return (args && args.value && args.value.trim()) || undefined;
-}
-
-export default class Autocomplete extends Workflow {
-
-  constructor(superworkflow, { defaults, ...args } = {}) {
-    super({
-      name: 'autocomplete',
-      plugin: superworkflow._plugin,
-      client: superworkflow._client,
-      defaults: shimDefaults(defaults),
-      roles: ROLES_OPTIONS,
-      superworkflow,
-      ...args,
-    });
-    this._autocompleteContext = superworkflow && superworkflow._context && superworkflow._context.autocomplete;
-  }
-
-  _initProperties(args) {
-    super._initProperties(args);
-    this._superworkflow = args.superworkflow;
-    this._active = args.defaults.active;
-  }
-
-  _initSubscriptions(args) {
-    // TODO: how to sync options updates
-    super._initSubscriptions(args);
-    this._unsubscribes = [
-      ...this._unsubscribes,
-      args.superworkflow._hub.on(fields.input(), args => this._query(args)),
-    ];
-  }
-
-  // API //
-  get enabled() {
-    return !!(this._active !== undefined ? this._active : this._autocompleteContext && this._autocompleteContext.enabled);
-  }
-
-  enable() {
-    this._active = true;
-  }
-
-  disable() {
-    this._active = false;
-  }
-
-  // query //
-  _query(args) {
-    if (!this.enabled || sameInputValue(args, this._args)) {
-      return;
-    }
-    this._args = args;
-
-    // start a new session
-    this.restart();
-    const { session } = this;
-    session.meta.input = args;
-
-    // if input value is blank, emit empty response
-    if (!getInputValue(args)) {
-      this._updateCompletions({ session, status: STATUS.INITIAL });
-      return;
-    }
-
-    // payload
-    const payload = this._buildPayload(args);
-
-    // request
-    this._request({ payload });
-  }
-
-  _buildPayload(args) {
-    return { q: getInputValue(args) };
-  }
-
-  // data //
-  _updateDataInHub(data) {
-    if (data.value) {
-      data = {
-        ...data,
-        value: data.value.completions,
-      };
-    }
-    // update completion field in superworkflow hub
-    this._updateCompletions(data);
-  }
-
-  _updateCompletions(data) {
-    // TODO: session is different
-    this._superworkflow.updateCompletions(data);
-  }
-
-}

package/src/workflow/base.js

@@ -1,396 +0,0 @@
-import { Component, isNullLike, mergeInteractions } from '@miso.ai/commons';
-import { Hub, SessionMaker, DataActor, ViewsActor, InteractionsActor, TrackersActor, proxyTrackers, fields } from '../actor/index.js';
-import * as sources from '../source.js';
-import { STATUS, ROLE } from '../constants.js';
-import { ContainerLayout, ErrorLayout } from '../layout/index.js';
-import { WorkflowOptions, mergeApiOptions, makeConfigurable } from './options/index.js';
-import {
-  getRevision,
-  writeRequestFromPreviousData,
-  writeDataStatus,
-  writeMisoIdToMeta,
-  buildBaseInteraction,
-  writeSessionInfoToInteraction,
-  writeRequestInfoToInteraction,
-  writeRequestMetadataToInteraction,
-  writeAffiliationInfoToInteraction,
-} from './processors.js';
-
-const DEFAULT_API_OPTIONS = Object.freeze({});
-
-const DEFAULT_LAYOUTS = Object.freeze({
-  [ROLE.CONTAINER]: ContainerLayout.type,
-  [ROLE.ERROR]: ErrorLayout.type,
-});
-
-const DEFAULT_TRACKERS = Object.freeze({});
-
-const DEFAULT_OPTIONS = Object.freeze({
-  api: DEFAULT_API_OPTIONS,
-  layouts: DEFAULT_LAYOUTS,
-  trackers: DEFAULT_TRACKERS,
-});
-
-const ROLES_OPTIONS = Object.freeze({
-  mappings: {
-    [ROLE.ERROR]: data => data.error,
-  },
-});
-
-export default class Workflow extends Component {
-
-  constructor(args) {
-    super(args.name || 'workflow', args.plugin);
-
-    let { context, plugin, client, defaults, options, extraOptions } = args;
-    this._context = context;
-    this._plugin = plugin = plugin || context._plugin;
-    this._client = client = client || context._client;
-    args = Object.freeze({ ...args, plugin, client });
-
-    this._name = args.name;
-    this._roles = args.roles;
-
-    this._extensions = plugin._getExtensions(client);
-    this._defaults = defaults;
-    this._options = options || new WorkflowOptions(context && context._options, defaults);
-    this._extraOptions = extraOptions || {};
-    this._hub = new Hub({
-      onUpdate: event => this._onHubUpdate(event),
-      onEmit: event => this._onHubEmit(event),
-    });
-    this._sessionContext = new WeakMap();
-    this._pluginContext = {
-      processInteractionPasses: [],
-    };
-
-    client._events.emit('workflow', this);
-
-    this._initProperties(args);
-    this._initActors(args);
-    this._initSubscriptions(args);
-    this._initSession(args);
-  }
-
-  _initProperties() {}
-
-  _initActors({ roles }) {
-    const hub = this._hub;
-    const client = this._client;
-    const options = this._options;
-    const extensions = this._extensions;
-    const layouts = this._plugin.layouts;
-
-    this._sessions = new SessionMaker(hub);
-    this._trackers = new TrackersActor(hub, { roles, options });
-    this._proxyTrackers = proxyTrackers(this._trackers);
-    this._data = new DataActor(hub, { source: sources.api(client), options, ...this._extraOptions.api });
-    this._views = new ViewsActor(hub, { extensions, layouts, roles, options, workflow: this });
-    this._interactions = new InteractionsActor(hub, { client, options });
-  }
-
-  _initSubscriptions({ roles }) {
-    this._unsubscribes = [
-      this._hub.on(fields.session(), session => this._onSession(session)),
-      this._hub.on(fields.response(), data => this.updateData(data)),
-      this._hub.on(fields.tracker(), args => this._onTracker(args)),
-    ];
-    if (roles.main) {
-      this._unsubscribes.push(this._hub.on(fields.view(roles.main), state => this._onMainViewUpdate(state)));
-    }
-  }
-
-  _initSession() {
-    this.restart();
-  }
-
-  _getSessionContext(session) {
-    let context = this._sessionContext.get(session);
-    if (!context) {
-      this._sessionContext.set(session, context = {});
-    }
-    return context;
-  }
-
-  // hub //
-  _onHubUpdate(event) {
-    this._runCallbacks(this._client.meta.parent._hubUpdateCallbacks, event);
-  }
-
-  _onHubEmit(event) {
-    this._runCallbacks(this._client.meta.parent._hubEmitCallbacks, event);
-    this._emitAsWorkflowEvent(event);
-  }
-
-  _emitAsWorkflowEvent({ action: _action, name, state, silent }) {
-    if (!silent) {
-      this._emit(name, { _action, ...state });
-    }
-  }
-
-  // properties //
-  get uuid() {
-    // TODO: review this
-    return this.session && this.session.uuid;
-  }
-
-  get session() {
-    return this._hub.states[fields.session()];
-  }
-
-  get states() {
-    return this._hub.states;
-  }
-
-  get status() {
-    const data = this._hub.states[fields.data()];
-    return data && data.status;
-  }
-
-  get views() {
-    return this._views.interface;
-  }
-
-  // lifecycle //
-  restart() {
-    this._emitInterruptEventIfNecessary();
-    this._sessions.restart();
-    return this;
-  }
-
-  _emitInterruptEventIfNecessary() {
-    const { main } = this._roles;
-    if (!main) {
-      return;
-    }
-    const state = this._hub.states[fields.view(main)] || {};
-    if (state.session && state.status === STATUS.LOADING) {
-      // it's interrupted by a new question
-      this._emitLifecycleEvent('interrupt', state);
-      this._emitLifecycleEvent('finally', state);
-    }
-  }
-
-  _onSession(session) {
-    this.updateData({ session });
-  }
-
-  _onMainViewUpdate(state) {
-    const { status } = state;
-    const done = status === STATUS.READY;
-    const erroneous = status === STATUS.ERRONEOUS;
-    const eventName = erroneous ? 'error' : status;
-    this._emitLifecycleEvent(eventName, state);
-    if (done) {
-      this._emitLifecycleEvent('done', state);
-    }
-    if (done || erroneous) {
-      this._emitLifecycleEvent('finally', state);
-    }
-  }
-
-  _shallEmitLifecycleEvent(name, { session }) {
-    const context = this._getSessionContext(session);
-    const events = context.lifecycleEvents || (context.lifecycleEvents = new Set());
-    const emitted = events.has(name);
-    events.add(name);
-    return !emitted;
-  }
-
-  _emitLifecycleEvent(name, event) {
-    if (!this._shallEmitLifecycleEvent(name, event)) {
-      return;
-    }
-    this._emit(name, event);
-  }
-
-  // request //
-  _request(options = {}) {
-    this._writeRequestTimeToSession(Date.now(), options);
-    const { session } = this;
-    const request = mergeApiOptions(this._options.resolved.api, options);
-    this.updateData({ session, request });
-    this._hub.update(fields.request(), { ...request, session });
-  }
-
-  _writeRequestTimeToSession(timestamp, options) {
-    const { session } = this;
-    session.meta.requestAt = timestamp;
-  }
-
-  // data //
-  updateData(data) {
-    if (!data) {
-      throw new Error(`Data is required.`);
-    }
-    const { session } = data;
-    if (!session) {
-      throw new Error(`Session is required to update data.`);
-    }
-    if (!this.session) {
-      throw new Error(`No session is created yet. Call workflow.restart() to start a new session.`);
-    }
-    if (session.uuid !== this.session.uuid) {
-      return; // ignore data for old session or inactive session
-    }
-
-    // compare revision to omit outdated data, if any
-    const revision = getRevision(data);
-    if (!isNullLike(revision)) {
-      const currentRevision = getRevision(this._hub.states[fields.data()]);
-      if (!isNullLike(currentRevision) && revision <= currentRevision) {
-        return;
-      }
-    }
-
-    this._updateData(data);
-
-    return this;
-  }
-
-  _updateData(data) {
-    const oldData = this._hub.states[fields.data()];
-    data = this._defaultProcessData(data, oldData);
-    for (const process of this._options.resolved.dataProcessor) {
-      data = process(data, oldData);
-    }
-
-    this._updateDataInHub(data, oldData);
-  }
-
-  _defaultProcessData(data, oldData) {
-    data = writeRequestFromPreviousData(data, oldData);
-    data = writeDataStatus(data);
-    data = writeMisoIdToMeta(data);
-    return data;
-  }
-
-  _updateDataInHub(data) {
-    this._hub.update(fields.data(), data);
-  }
-
-  // TODO: notifyViewUpdateAll()
-
-  notifyViewUpdate(role, state) {
-    state = {
-      status: STATUS.READY,
-      session: this.session,
-      ...state,
-    };
-    this._hub.update(fields.view(role), state);
-    return this;
-  }
-
-  // trackers //
-  get trackers() {
-    return this._proxyTrackers;
-  }
-
-  _onTracker(args) {
-    const workflow = this;
-    const data = this._hub.states[fields.data()];
-    const payload = this._buildInteraction({ ...args, data, workflow });
-    this._sendInteraction(payload);
-  }
-
-  _buildInteraction(args) {
-    let payload = buildBaseInteraction(args);
-    payload = this._defaultProcessInteraction(payload, args);
-    for (const p of this._pluginContext.processInteractionPasses) {
-      payload = p(payload, args);
-    }
-    const { preprocess = [] } = this._options.resolved.interactions;
-    for (const p of preprocess) {
-      payload = p(payload, args);
-    }
-    return payload;
-  }
-
-  _defaultProcessInteraction(payload, args) {
-    payload = this._writeApiInfoToInteraction(payload, args);
-    payload = this._writeMisoIdToInteraction(payload, args);
-    payload = writeSessionInfoToInteraction(payload, args);
-    payload = writeRequestInfoToInteraction(payload, args);
-    payload = writeRequestMetadataToInteraction(payload, args);
-    payload = writeAffiliationInfoToInteraction(payload, args);
-    return payload;
-  }
-
-  _writeApiInfoToInteraction(payload) {
-    const { group, name } = this._options.resolved.api;
-    return mergeInteractions(payload, {
-      context: {
-        custom_context: {
-          api_group: group,
-          api_name: name,
-        },
-      },
-    });
-  }
-
-  _writeMisoIdToInteraction(payload, args) {
-    // TODO: ad-hoc, try to pass info from tracker
-    const state = this._hub.states[fields.view(args.role)] || {};
-    const miso_id = (state.meta && state.meta.miso_id) || undefined;
-    return miso_id ? mergeInteractions(payload, { miso_id }) : payload;
-  }
-
-  _sendInteraction(payload) {
-    const { handle } = this._options.resolved.interactions;
-    if (typeof handle === 'function') {
-      handle(payload);
-    } else {
-      this._hub.trigger(fields.interaction(), payload);
-    }
-  }
-
-  // destroy //
-  destroy(options) {
-    this._emit('destroy');
-    this._destroy(options);
-  }
-
-  get destroyed() {
-    return !!this._destroyed;
-  }
-
-  _destroy({ dom } = {}) {
-    for (const unsubscribe of this._unsubscribes || []) {
-      unsubscribe();
-    }
-    this._unsubscribes = [];
-
-    this._views._destroy({ dom });
-    this._data._destroy();
-    this._destroyed = true;
-  }
-
-  // helper //
-  _runCallbacks(callbacks, event) {
-    for (const callback of callbacks) {
-      try {
-        callback({ workflow: this, ...event });
-      } catch (e) {
-        this._error(e);
-      }
-    }
-  }
-
-  _emit(name, data) {
-    this._events.emit(name, { _event: name, ...data });
-    if (this._context) {
-      this._context._events.emit(name, { workflow: this, _event: name, ...data });
-    }
-  }
-
-}
-
-makeConfigurable(Workflow.prototype);
-
-Object.assign(Workflow, {
-  DEFAULT_API_OPTIONS,
-  DEFAULT_LAYOUTS,
-  DEFAULT_TRACKERS,
-  DEFAULT_OPTIONS,
-  ROLES_OPTIONS,
-});