@mdxeditor/editor 0.0.1 → 0.0.4-development

package/dist/exportMarkdownFromLexical.js

@@ -0,0 +1,239 @@
+import { $isElementNode } from "lexical";
+import { toMarkdown } from "mdast-util-to-markdown";
+import { isMdastHTMLNode } from "./plugins/core/MdastHTMLNode.js";
+import { mergeStyleAttributes } from "./utils/mergeStyleAttributes.js";
+function isParent(node) {
+  return node.children instanceof Array;
+}
+function exportLexicalTreeToMdast({
+  root,
+  visitors,
+  jsxComponentDescriptors,
+  jsxIsAvailable,
+  addImportStatements = true
+}) {
+  let unistRoot = null;
+  const referredComponents = /* @__PURE__ */ new Set();
+  visitors = visitors.sort((a, b) => (b.priority ?? 0) - (a.priority ?? 0));
+  visit(root, null);
+  function registerReferredComponent(componentName) {
+    referredComponents.add(componentName);
+  }
+  function appendToParent(parentNode, node) {
+    if (unistRoot === null) {
+      unistRoot = node;
+      return unistRoot;
+    }
+    if (!isParent(parentNode)) {
+      throw new Error("Attempting to append children to a non-parent");
+    }
+    const siblings = parentNode.children;
+    const prevSibling = siblings.at(-1);
+    if (prevSibling) {
+      const joinVisitor = visitors.find((visitor) => {
+        var _a;
+        return (_a = visitor.shouldJoin) == null ? void 0 : _a.call(visitor, prevSibling, node);
+      });
+      if (joinVisitor) {
+        const joinedNode = joinVisitor.join(prevSibling, node);
+        siblings.splice(siblings.length - 1, 1, joinedNode);
+        return joinedNode;
+      }
+    }
+    siblings.push(node);
+    return node;
+  }
+  function visitChildren(lexicalNode, parentNode) {
+    lexicalNode.getChildren().forEach((lexicalChild) => {
+      visit(lexicalChild, parentNode);
+    });
+  }
+  function visit(lexicalNode, mdastParent) {
+    var _a;
+    const visitor = visitors.find((visitor2) => {
+      var _a2;
+      return (_a2 = visitor2.testLexicalNode) == null ? void 0 : _a2.call(visitor2, lexicalNode);
+    });
+    if (!visitor) {
+      throw new Error(`no lexical visitor found for ${lexicalNode.getType()}`, {
+        cause: lexicalNode
+      });
+    }
+    (_a = visitor.visitLexicalNode) == null ? void 0 : _a.call(visitor, {
+      lexicalNode,
+      mdastParent,
+      actions: {
+        addAndStepInto(type, props = {}, hasChildren = true) {
+          const newNode = {
+            type,
+            ...props,
+            ...hasChildren ? { children: [] } : {}
+          };
+          appendToParent(mdastParent, newNode);
+          if ($isElementNode(lexicalNode) && hasChildren) {
+            visitChildren(lexicalNode, newNode);
+          }
+        },
+        appendToParent,
+        visitChildren,
+        registerReferredComponent
+      }
+    });
+  }
+  if (unistRoot === null) {
+    throw new Error("traversal ended with no root element");
+  }
+  const importsMap = /* @__PURE__ */ new Map();
+  const defaultImportsMap = /* @__PURE__ */ new Map();
+  for (const componentName of referredComponents) {
+    const descriptor = jsxComponentDescriptors.find((descriptor2) => descriptor2.name === componentName);
+    if (!descriptor) {
+      throw new Error(`Component ${componentName} is used but not imported`);
+    }
+    if (!descriptor.source) {
+      continue;
+    }
+    if (descriptor.defaultExport) {
+      defaultImportsMap.set(componentName, descriptor.source);
+    } else {
+      const { source } = descriptor;
+      const existing = importsMap.get(source);
+      if (existing) {
+        existing.push(componentName);
+      } else {
+        importsMap.set(source, [componentName]);
+      }
+    }
+  }
+  const imports = Array.from(importsMap).map(([source, componentNames]) => {
+    return {
+      type: "mdxjsEsm",
+      value: `import { ${componentNames.join(", ")} } from '${source}'`
+    };
+  });
+  imports.push(
+    ...Array.from(defaultImportsMap).map(([componentName, source]) => {
+      return {
+        type: "mdxjsEsm",
+        value: `import ${componentName} from '${source}'`
+      };
+    })
+  );
+  const typedRoot = unistRoot;
+  const frontmatter = typedRoot.children.find((child) => child.type === "yaml");
+  if (addImportStatements) {
+    if (frontmatter) {
+      typedRoot.children.splice(typedRoot.children.indexOf(frontmatter) + 1, 0, ...imports);
+    } else {
+      typedRoot.children.unshift(...imports);
+    }
+  }
+  fixWrappingWhitespace(typedRoot, []);
+  collapseNestedHtmlTags(typedRoot);
+  if (!jsxIsAvailable) {
+    convertUnderlineJsxToHtml(typedRoot);
+  }
+  return typedRoot;
+}
+function collapseNestedHtmlTags(node) {
+  if ("children" in node && node.children) {
+    if (isMdastHTMLNode(node) && node.children.length === 1) {
+      const onlyChild = node.children[0];
+      if (onlyChild.type === "mdxJsxTextElement" && onlyChild.name === "span") {
+        (onlyChild.attributes || []).forEach((attribute) => {
+          var _a;
+          if (attribute.type === "mdxJsxAttribute") {
+            const parentAttribute = (_a = node.attributes) == null ? void 0 : _a.find((attr) => attr.type === "mdxJsxAttribute" && attr.name === attribute.name);
+            if (parentAttribute) {
+              if (attribute.name === "className") {
+                const mergedClassesSet = /* @__PURE__ */ new Set([
+                  ...parentAttribute.value.split(" "),
+                  ...attribute.value.split(" ")
+                ]);
+                parentAttribute.value = Array.from(mergedClassesSet).join(" ");
+              } else if (attribute.name === "style") {
+                parentAttribute.value = mergeStyleAttributes(parentAttribute.value, attribute.value);
+              }
+            } else {
+              node.attributes.push(attribute);
+            }
+          }
+        });
+        node.children = onlyChild.children;
+      }
+    }
+    node.children.forEach((child) => collapseNestedHtmlTags(child));
+  }
+}
+function convertUnderlineJsxToHtml(node) {
+  if (Object.hasOwn(node, "children")) {
+    const nodeAsParent = node;
+    const newChildren = [];
+    nodeAsParent.children.forEach((child) => {
+      if (child.type === "mdxJsxTextElement" && child.name === "u") {
+        newChildren.push(...[{ type: "html", value: "<u>" }, ...child.children, { type: "html", value: "</u>" }]);
+      } else {
+        newChildren.push(child);
+        convertUnderlineJsxToHtml(child);
+      }
+    });
+    nodeAsParent.children = newChildren;
+  }
+}
+const TRAILING_WHITESPACE_REGEXP = /\s+$/;
+const LEADING_WHITESPACE_REGEXP = /^\s+/;
+function fixWrappingWhitespace(node, parentChain) {
+  if (node.type === "strong" || node.type === "emphasis") {
+    const lastChild = node.children.at(-1);
+    if ((lastChild == null ? void 0 : lastChild.type) === "text") {
+      const trailingWhitespace = lastChild.value.match(TRAILING_WHITESPACE_REGEXP);
+      if (trailingWhitespace) {
+        lastChild.value = lastChild.value.replace(TRAILING_WHITESPACE_REGEXP, "");
+        const parent = parentChain.at(-1);
+        if (parent) {
+          parent.children.splice(parent.children.indexOf(node) + 1, 0, {
+            type: "text",
+            value: trailingWhitespace[0]
+          });
+          fixWrappingWhitespace(parent, parentChain.slice(0, -1));
+        }
+      }
+    }
+    const firstChild = node.children.at(0);
+    if ((firstChild == null ? void 0 : firstChild.type) === "text") {
+      const leadingWhitespace = firstChild.value.match(LEADING_WHITESPACE_REGEXP);
+      if (leadingWhitespace) {
+        firstChild.value = firstChild.value.replace(LEADING_WHITESPACE_REGEXP, "");
+        const parent = parentChain.at(-1);
+        if (parent) {
+          parent.children.splice(parent.children.indexOf(node), 0, {
+            type: "text",
+            value: leadingWhitespace[0]
+          });
+          fixWrappingWhitespace(parent, parentChain.slice(0, -1));
+        }
+      }
+    }
+  }
+  if ("children" in node && node.children) {
+    const nodeAsParent = node;
+    nodeAsParent.children.forEach((child) => fixWrappingWhitespace(child, [...parentChain, nodeAsParent]));
+  }
+}
+function exportMarkdownFromLexical({
+  root,
+  toMarkdownOptions,
+  toMarkdownExtensions,
+  visitors,
+  jsxComponentDescriptors,
+  jsxIsAvailable
+}) {
+  return toMarkdown(exportLexicalTreeToMdast({ root, visitors, jsxComponentDescriptors, jsxIsAvailable }), {
+    extensions: toMarkdownExtensions,
+    ...toMarkdownOptions
+  });
+}
+export {
+  exportLexicalTreeToMdast,
+  exportMarkdownFromLexical
+};

package/dist/gurx/index.d.ts

@@ -0,0 +1,3 @@
+export * from './realm';
+export * from './react';
+export * from './realmFactory';

package/dist/gurx/react.d.ts

@@ -0,0 +1,152 @@
+import React from 'react';
+import { RealmNode } from './realm';
+import type { ValuesForKeys, TypedRealm,  System,  RealmFactory,  ValueForKey,  SystemKeys,  SystemDict,  AnySystemSpec,  SystemOfSpecs } from './realmFactory';
+/**
+ * Describes the mapping between the system streams and the component properties.
+ * Each property uses the keys as the names of the properties and the values as the corresponding stream names.
+ * @typeParam SS - the type of the system.
+ */
+export interface SystemPropsMap<Sys extends System, K = keyof Sys, D = {
+    [name: string]: K;
+}> {
+    /**
+     * Specifies the required component properties.
+     */
+    required?: D;
+    /**
+     * Specifies the optional component properties.
+     */
+    optional?: D;
+    /**
+     * Specifies the component methods, if any. Streams are converted to methods with a single argument.
+     * When invoked, the method publishes the value of the argument to the specified stream.
+     */
+    methods?: D;
+    /**
+     * Specifies the component "event" properties, if any.
+     * Event properties accept callback functions which get executed when the stream emits a new value.
+     */
+    events?: D;
+}
+type StringKeys<T> = Extract<keyof T, string>;
+/** @internal */
+export type PropsFromPropMap<Sys extends System, Map extends SystemPropsMap<Sys>> = {
+    [K in StringKeys<Map['required']>]: Map['required'][K] extends string ? Sys[Map['required'][K]] extends RealmNode<infer R> ? R : never : never;
+} & {
+    [K in StringKeys<Map['optional']>]?: Map['optional'][K] extends string ? Sys[Map['optional'][K]] extends RealmNode<infer R> ? R : never : never;
+} & {
+    [K in StringKeys<Map['events']>]?: Map['events'][K] extends string ? Sys[Map['events'][K]] extends RealmNode<infer R> ? (value: R) => void : never : never;
+};
+/** @internal */
+export type MethodsFromPropMap<Sys extends System, Map extends SystemPropsMap<Sys>> = {
+    [K in StringKeys<Map['methods']>]: Map['methods'][K] extends string ? Sys[Map['methods'][K]] extends RealmNode<infer R> ? (value: R) => void : never : never;
+};
+/**
+ * @internal
+ * Used to correctly specify type refs for system components.
+ *
+ * @example
+ * ```tsx
+ * const s = system(() => { return { a: statefulStream(0) } })
+ * const { Component } = systemToComponent(s)
+ *
+ * const App = () => {
+ *  const ref = useRef<RefHandle<typeof Component>>()
+ *  return <Component ref={ref} />
+ * }
+ * ```
+ *
+ * @typeParam T - the type of the component
+ */
+export type RefHandle<T> = T extends React.ForwardRefExoticComponent<React.RefAttributes<infer Handle>> ? Handle : never;
+/**
+ * Converts a system spec to React component by mapping the system streams to component properties, events and methods. Returns hooks for querying and modifying
+ * the system streams from the component's child components.
+ * @param realmFactory - The return value from a [[system]] call.
+ * @param map - The streams to props / events / methods mapping Check [[SystemPropsMap]] for more details.
+ * @param Root - The optional React component to render. By default, the resulting component renders nothing, acting as a logical wrapper for its children.
+ * @returns an object containing the following:
+ *  - `Component`: the React component.
+ *  - `useEmitterValue`: a hook that lets child components use values emitted from the specified output stream.
+ *  - `useEmitter`: a hook that calls the provided callback whenever the specified stream emits a value.
+ *  - `usePublisher`: a hook which lets child components publish values to the specified stream.
+ *  <hr />
+ */
+export declare function realmFactoryToComponent<RootComp, RF extends RealmFactory<Sys>, Sys extends System = RF extends RealmFactory<infer S> ? S : never, Realm extends TypedRealm<Sys> = TypedRealm<Sys>, M extends SystemPropsMap<Sys> = SystemPropsMap<Sys>>(realmFactory: RF, map: M, Root?: RootComp): {
+    useRealmContext: () => TypedRealm<Sys>;
+    useEmitter: <K extends Extract<keyof Sys, string>>(key: K, callback: (value: ValueForKey<Sys, K>) => void) => void;
+    useEmitterValues: <K_1 extends SystemKeys<Sys>>(...keys: K_1) => ValuesForKeys<Sys, K_1>;
+    usePubKeys: () => (values: SystemDict<Sys>) => void;
+    usePublisher: <K_2 extends keyof Sys>(key: K_2) => (value: ValueForKey<Sys, K_2>) => void;
+    Component: React.ForwardRefExoticComponent<React.PropsWithoutRef<{ [K_3 in Extract<keyof M["required"], string>]: M["required"][K_3] extends string ? Sys[M["required"][K_3]] extends RealmNode<infer R> ? R : never : never; } & { [K_4 in Extract<keyof M["optional"], string>]?: (M["optional"][K_4] extends string ? Sys[M["optional"][K_4]] extends RealmNode<infer R_1> ? R_1 : never : never) | undefined; } & { [K_5 in Extract<keyof M["events"], string>]?: (M["events"][K_5] extends string ? Sys[M["events"][K_5]] extends RealmNode<infer R_2> ? (value: R_2) => void : never : never) | undefined; } & (RootComp extends React.ComponentType<infer RP> ? RP : {
+        children?: React.ReactNode;
+    })> & React.RefAttributes<MethodsFromPropMap<Sys, M>>>;
+};
+/** @internal */
+export declare function sysHooks<Sys extends System>(): {
+    useRealmContext: () => TypedRealm<Sys>;
+    useEmitter: <K extends Extract<keyof Sys, string>>(key: K, callback: (value: ValueForKey<Sys, K>) => void) => void;
+    useEmitterValues: <K_1 extends SystemKeys<Sys>>(...keys: K_1) => ValuesForKeys<Sys, K_1>;
+    usePubKeys: () => (values: SystemDict<Sys>) => void;
+    usePublisher: <K_2 extends keyof Sys>(key: K_2) => (value: ValueForKey<Sys, K_2>) => void;
+};
+type SystemAndDependencies<Spec extends AnySystemSpec> = SystemOfSpecs<[Spec]> & SystemOfSpecs<Spec['dependencies']>;
+/**
+ * The parameters of a plugin declaration. THe best way to understand what each one does is to examine the source code of the existing plugins.
+ */
+export interface RealmPluginParams<Spec extends AnySystemSpec, Params extends object> {
+    /**
+     * The id of the plugin. Used to declare conditional features that are activated only if the plugin is present.
+     */
+    id: string;
+    /**
+     * The ids of the plugins that this plugin depends on. The plugin will not be activated if any of the dependencies is not present.
+     */
+    dependencies?: string[];
+    /**
+     * The system spec of the plugin. Construct one using {@link system}.
+     */
+    systemSpec: Spec;
+    /**
+     * The callback is executed every time the react component is re-rendered.
+     */
+    applyParamsToSystem?: (realm: TypedRealm<SystemAndDependencies<Spec>>, props: Params) => void;
+    /**
+     * Executed when the component mounts. Use this to register import/export visitors, add lexical nodes to the editor, etc.
+     * @param realm - the realm instance
+     * @param params - the parameters passed to the plugin in the component declaration
+     * @param pluginIds - the ids of all the plugins that are present in the component declaration
+     */
+    init?: (realm: TypedRealm<SystemAndDependencies<Spec>>, params: Params, pluginIds: string[]) => void;
+}
+/** @internal */
+export interface PluginConstructor<Spec extends AnySystemSpec, Params extends object> {
+    (params?: Params): {
+        pluginParams?: Params;
+    } & RealmPluginParams<Spec, Params>;
+}
+/**
+ * Declares a new MDXEditor plugin.
+ */
+export declare function realmPlugin<Spec extends AnySystemSpec, Params extends object>(params: RealmPluginParams<Spec, Params>): readonly [PluginConstructor<Spec, Params>, {
+    useRealmContext: () => TypedRealm<SystemAndDependencies<Spec>>;
+    useEmitter: <K extends Extract<keyof (Spec extends AnySystemSpec ? {} & ReturnType<Spec["constructor"]> : never), string> | Extract<keyof SystemOfSpecs<Spec["dependencies"]>, string>>(key: K, callback: (value: ValueForKey<SystemAndDependencies<Spec>, K>) => void) => void;
+    useEmitterValues: <K_1 extends SystemKeys<SystemAndDependencies<Spec>>>(...keys: K_1) => ValuesForKeys<SystemAndDependencies<Spec>, K_1>;
+    usePubKeys: () => (values: SystemDict<SystemAndDependencies<Spec>>) => void;
+    usePublisher: <K_2 extends keyof (Spec extends AnySystemSpec ? {} & ReturnType<Spec["constructor"]> : never) | keyof SystemOfSpecs<Spec["dependencies"]>>(key: K_2) => (value: ValueForKey<SystemAndDependencies<Spec>, K_2>) => void;
+}];
+/** @internal */
+export declare const RealmPluginInitializer: <P extends ({
+    pluginParams?: any;
+} & RealmPluginParams<AnySystemSpec, any>)[]>({ plugins, children }: {
+    plugins: P;
+    children?: React.ReactNode;
+}) => React.FunctionComponentElement<React.ProviderProps<TypedRealm<any>>>;
+/** @internal */
+export declare function useHasPlugin(id: string): boolean;
+/** @internal */
+export declare const RequirePlugin: React.FC<{
+    id: string;
+    children: React.ReactNode;
+}>;
+export {};

package/dist/gurx/react.js

@@ -0,0 +1,206 @@
+import React__default, { useEffect } from "react";
+import { tap, always } from "../utils/fp.js";
+import { realmFactory } from "./realmFactory.js";
+function omit(keys, obj) {
+  const result = {};
+  const index = {};
+  let idx = 0;
+  const len = keys.length;
+  while (idx < len) {
+    index[keys[idx]] = 1;
+    idx += 1;
+  }
+  for (const prop in obj) {
+    if (!Object.prototype.hasOwnProperty.call(index, prop)) {
+      result[prop] = obj[prop];
+    }
+  }
+  return result;
+}
+const useIsomorphicLayoutEffect = typeof document !== "undefined" ? React__default.useLayoutEffect : React__default.useEffect;
+const GurxContext = React__default.createContext(void 0);
+function realmFactoryToComponent(realmFactory2, map, Root) {
+  const requiredPropNames = Object.keys(map.required || {});
+  const optionalPropNames = Object.keys(map.optional || {});
+  const methodNames = Object.keys(map.methods || {});
+  const eventNames = Object.keys(map.events || {});
+  const Context = GurxContext;
+  function applyPropsToRealm(realm, props) {
+    const toBePublished = {};
+    for (const requiredPropName of requiredPropNames) {
+      const nodeName = map.required[requiredPropName];
+      toBePublished[nodeName] = props[requiredPropName];
+    }
+    for (const optionalPropName of optionalPropNames) {
+      const value = props[optionalPropName];
+      if (value !== void 0) {
+        const nodeName = map.optional[optionalPropName];
+        toBePublished[nodeName] = value;
+      }
+    }
+    realm.pubKeys(toBePublished);
+  }
+  function buildMethods(realm) {
+    return methodNames.reduce((acc, methodName) => {
+      const nodeName = map.methods[methodName];
+      acc[methodName] = (value) => {
+        realm.pubKey(nodeName, value);
+      };
+      return acc;
+    }, {});
+  }
+  const Component = React__default.forwardRef((props, ref) => {
+    const realm = React__default.useMemo(() => {
+      return tap(realmFactory2(), (realm2) => applyPropsToRealm(realm2, props));
+    }, []);
+    useIsomorphicLayoutEffect(() => {
+      applyPropsToRealm(realm, props);
+      realm.resetSingletonSubs();
+      for (const eventName of eventNames) {
+        if (eventName in props) {
+          realm.singletonSubKey(map.events[eventName], props[eventName]);
+        }
+      }
+      return () => {
+        realm.resetSingletonSubs();
+      };
+    }, [props]);
+    React__default.useImperativeHandle(ref, always(buildMethods(realm)));
+    const children = props.children;
+    return React__default.createElement(
+      Context.Provider,
+      { value: realm },
+      Root ? React__default.createElement(
+        Root,
+        omit([...requiredPropNames, ...optionalPropNames, ...eventNames], props),
+        children
+      ) : children
+    );
+  });
+  Component.displayName = "Gurx Component";
+  return {
+    Component,
+    ...sysHooks()
+  };
+}
+function sysHooks() {
+  const Context = GurxContext;
+  const usePublisher = (key) => {
+    const realm = React__default.useContext(Context);
+    return React__default.useCallback(
+      (value) => {
+        realm.pubKey(key, value);
+      },
+      // eslint-disable-next-line react-hooks/exhaustive-deps
+      [key, realm]
+    );
+  };
+  const useEmitterValues = (...keys) => {
+    const realm = React__default.useContext(Context);
+    const [values, setValues] = React__default.useState(() => realm.getKeyValues(keys));
+    useEffect(
+      () => realm == null ? void 0 : realm.subKeys(keys, (newValues) => {
+        const setter = () => {
+          if (keys.length === 1) {
+            newValues = [newValues];
+          }
+          for (let i = 0; i < keys.length; i++) {
+            if (newValues[i] !== values[i]) {
+              setValues(newValues);
+            }
+          }
+        };
+        setter();
+      }),
+      [keys, realm, values]
+    );
+    return values;
+  };
+  const usePubKeys = () => {
+    return React__default.useContext(Context).pubKeys;
+  };
+  const useEmitter = (key, callback) => {
+    const realm = React__default.useContext(Context);
+    useIsomorphicLayoutEffect(() => realm.subKey(key, callback), [callback]);
+  };
+  const useRealmContext = () => {
+    return React__default.useContext(Context);
+  };
+  return {
+    useRealmContext,
+    useEmitter,
+    useEmitterValues,
+    usePubKeys,
+    usePublisher
+  };
+}
+const UsedPluginsContext = React__default.createContext(/* @__PURE__ */ new Set());
+function realmPlugin(params) {
+  const plugin = (pluginParams) => {
+    return {
+      systemSpec: params.systemSpec,
+      pluginParams,
+      applyParamsToSystem: params.applyParamsToSystem,
+      init: params.init,
+      id: params.id,
+      dependencies: params.dependencies
+    };
+  };
+  return [plugin, sysHooks()];
+}
+const RealmPluginInitializer = function({
+  plugins,
+  children
+}) {
+  const validPlugins = React__default.useMemo(() => {
+    const availablePlugins = plugins.map((plugin) => plugin.id);
+    const validPlugins2 = plugins.filter((plugin) => {
+      if (plugin.dependencies) {
+        if (plugin.dependencies.some((dep) => !availablePlugins.includes(dep))) {
+          console.warn("MDXEditor plugin", plugin.id, "has some missing dependencies", plugin.dependencies, ", skipping");
+          return false;
+        }
+      }
+      return true;
+    });
+    return validPlugins2;
+  }, [plugins]);
+  const realm = React__default.useMemo(() => {
+    const specs = validPlugins.map((plugin) => plugin.systemSpec);
+    const pluginIds = validPlugins.map((plugin) => plugin.id);
+    const realm2 = realmFactory(...specs);
+    validPlugins.forEach((plugin) => {
+      var _a, _b;
+      (_a = plugin.init) == null ? void 0 : _a.call(plugin, realm2, plugin.pluginParams, pluginIds);
+      (_b = plugin.applyParamsToSystem) == null ? void 0 : _b.call(plugin, realm2, plugin.pluginParams);
+    });
+    return realm2;
+  }, []);
+  React__default.useEffect(() => {
+    validPlugins.forEach((plugin) => {
+      var _a;
+      (_a = plugin.applyParamsToSystem) == null ? void 0 : _a.call(plugin, realm, plugin.pluginParams);
+    });
+  }, [realm, validPlugins]);
+  const Context = GurxContext;
+  return React__default.createElement(
+    Context.Provider,
+    { value: realm },
+    React__default.createElement(UsedPluginsContext.Provider, { value: new Set(plugins.map((plugin) => plugin.id)) }, children)
+  );
+};
+function useHasPlugin(id) {
+  const usedPlugins = React__default.useContext(UsedPluginsContext);
+  return usedPlugins.has(id);
+}
+const RequirePlugin = ({ id, children }) => {
+  return useHasPlugin(id) ? React__default.createElement(React__default.Fragment, {}, children) : null;
+};
+export {
+  RealmPluginInitializer,
+  RequirePlugin,
+  realmFactoryToComponent,
+  realmPlugin,
+  sysHooks,
+  useHasPlugin
+};