@merkur/core/lib/index.cjs

Merkur is tiny and extensible library for creating front-end microservices.

'use strict';

function createBoundedFunction(widget, originalFunction) {
  return (...rest) => {
    return originalFunction(widget, ...rest);
  };
}

// @TODO in future use structuredClone instead of JSON.parse
function clone(object) {
  try {
    return JSON.parse(JSON.stringify(object));
  } catch (_) {
    return object;
  }
}

function setDefaultValueForUndefined(object, keys, value = {}) {
  let objectClone = { ...object };

  keys.forEach((key) => {
    objectClone[key] = objectClone[key] || clone(value);
  });

  return objectClone;
}

function bindWidgetToFunctions(widget, target) {
  target = target || widget;
  Object.keys(target).forEach((key) => {
    if (isFunction(target[key])) {
      let originalFunction = target[key];

      target[key] = createBoundedFunction(widget, originalFunction);
    }
  });
}

function hookMethod(widget, path, handler) {
  const { target, methodName } = parsePath(widget, path);
  const originalFunction = createBoundedFunction(widget, target[methodName]);

  target[methodName] = function (widget, ...rest) {
    return handler(widget, originalFunction, ...rest);
  };

  return originalFunction;
}

function parsePath(widget, path = '') {
  const paths = path.split('.');
  const methodName = paths.pop();
  const target = paths.reduce((target, path) => target[path] || {}, widget);

  if (!isFunction(target[methodName])) {
    throw new Error(
      `Defined path '${path}' is incorrect. Check your widget structure.`,
    );
  }

  return { target, methodName };
}

function isFunction(value) {
  return typeof value === 'function';
}

function assignMissingKeys(target, ...sources) {
  sources.forEach((source) => {
    Object.keys(source || {}).forEach((key) => {
      if (!(key in target)) {
        target[key] = source[key];
      }
    });
  });

  return target;
}

async function callPluginMethod(widget, method, args) {
  for (const plugin of widget.$plugins) {
    if (isFunction(plugin[method])) {
      widget = await plugin[method](widget, ...args);
    }
  }

  return widget;
}

/**
 * Typed helper to make it easier to define widget properties.
 *
 * @type import('@merkur/core').defineWidget
 */
function defineWidget(widgetDefinition) {
  return widgetDefinition;
}

function setDefinitionDefaults(widgetDefinition) {
  return {
    ...widgetDefinition,
    ...setDefaultValueForUndefined(
      widgetDefinition,
      ['containerSelector'],
      null,
    ),
    ...setDefaultValueForUndefined(widgetDefinition, [
      'slot',
      '$dependencies',
      '$external',
    ]),
    ...setDefaultValueForUndefined(
      widgetDefinition,
      ['setup', 'create'],
      (widget) => widget,
    ),
  };
}

/**
 * @type import('@merkur/core').createMerkurWidget
 */
async function createMerkurWidget(widgetDefinition = {}) {
  const definition = setDefinitionDefaults(widgetDefinition);
  const { setup, create } = definition;

  let widget = {
    async setup(widget, ...rest) {
      widget = await callPluginMethod(widget, 'setup', rest);

      return setup(widget, ...rest);
    },
    async create(widget, ...rest) {
      widget = await callPluginMethod(widget, 'create', rest);

      return create(widget, ...rest);
    },
    $plugins: (definition.$plugins || []).map((pluginFactory) =>
      pluginFactory(),
    ),
  };

  // TODO refactoring
  widget.name = definition.name;
  widget.version = definition.version;
  widget.$dependencies = definition.$dependencies;
  widget.$external = definition.$external;
  widget.$in = {};

  delete definition.name;
  delete definition.version;
  delete definition.$dependencies;
  delete definition.$external;
  delete definition.$plugins;

  delete definition.setup;
  delete definition.create;

  widget = await widget.setup(widget, definition);
  widget = await widget.create(widget, definition);

  bindWidgetToFunctions(widget);
  Object.seal(widget);

  return widget;
}

function register({ name, version, createWidget }) {
  const merkur = getMerkur();

  merkur.$in.widgetFactory[name + version] = createWidget;
}

function create(widgetProperties = {}) {
  const merkur = getMerkur();
  const { name, version } = widgetProperties;
  const factory = merkur.$in.widgetFactory[name + version];

  if (!isFunction(factory)) {
    throw new Error(
      `The widget with defined name and version "${
        name + version
      }" is not defined.`,
    );
  }

  return factory(widgetProperties);
}

function createMerkur({ $plugins = [] } = {}) {
  const merkur = getMerkur();

  $plugins.forEach((plugin) => {
    if (plugin && isFunction(plugin.setup)) {
      plugin.setup(merkur);
    }
  });

  return merkur;
}

function removeMerkur() {
  const globalContext = getGlobalContext();

  delete globalContext.__merkur__;
}

function getMerkur() {
  const globalContext = getGlobalContext();

  if (!globalContext.__merkur__) {
    globalContext.__merkur__ = {
      $in: {
        widgets: [],
        widgetFactory: {},
      },
      $external: {},
      $dependencies: {},
      isRegistered,
      register,
      create,
    };
  }

  return globalContext.__merkur__;
}

function isRegistered(name) {
  const merkur = getMerkur();

  return Boolean(
    Object.keys(merkur.$in.widgetFactory).find((key) =>
      new RegExp(`^${name}`).test(key),
    ),
  );
}

function getGlobalContext() {
  if (typeof globalThis !== 'undefined') {
    return globalThis;
  }
  if (typeof self !== 'undefined') {
    return self;
  }
  if (typeof window !== 'undefined') {
    return window;
  }
  if (typeof global !== 'undefined') {
    return global;
  }

  return {};
}

exports.assignMissingKeys = assignMissingKeys;
exports.bindWidgetToFunctions = bindWidgetToFunctions;
exports.createMerkur = createMerkur;
exports.createMerkurWidget = createMerkurWidget;
exports.defineWidget = defineWidget;
exports.getMerkur = getMerkur;
exports.hookMethod = hookMethod;
exports.isFunction = isFunction;
exports.removeMerkur = removeMerkur;
exports.setDefaultValueForUndefined = setDefaultValueForUndefined;