piral-core 0.15.0-alpha.3592 → 0.15.0-alpha.3640

package/src/RootListener.tsx

@@ -1,5 +1,5 @@
 import * as React from 'react';
-import { useGlobalStateContext } from '.';
+import { useGlobalStateContext } from './hooks';
 import { renderElement } from './modules';
 
 export const RootListener: React.FC = () => {

package/src/components/ExtensionSlot.tsx

@@ -1,8 +1,30 @@
 import * as React from 'react';
 import { isfunc } from 'piral-base';
-import { useGlobalState } from '../hooks';
+import { wrapComponent } from './wrapComponent';
+import { useGlobalState, useGlobalStateContext } from '../hooks';
 import { defaultRender, none } from '../utils';
-import { ExtensionSlotProps } from '../types';
+import { ExtensionRegistration, ExtensionSlotProps } from '../types';
+
+const renderExtensions: [ExtensionRegistration] = [
+  {
+    component: (props) => {
+      const context = useGlobalStateContext();
+      const converters = context.converters;
+      const piral = context.apis._;
+      const { component, props: args } = props.params;
+      const Component = React.useMemo(
+        () => wrapComponent(converters, component, { piral }, defaultRender),
+        [component],
+      );
+      return <Component {...args} />;
+    },
+    defaults: {},
+    pilet: '',
+    reference: {
+      displayName: 'RenderExtension',
+    },
+  },
+];
 
 /**
  * The extension slot component to be used when the available
@@ -11,7 +33,7 @@ import { ExtensionSlotProps } from '../types';
  */
 export function ExtensionSlot<T extends string>(props: ExtensionSlotProps<T>) {
   const { name, render = defaultRender, empty, params, children } = props;
-  const extensions = useGlobalState((s) => s.registry.extensions[name] || none);
+  const extensions = useGlobalState((s) => (name ? s.registry.extensions[name] || none : renderExtensions));
   return render(
     extensions.length === 0 && isfunc(empty)
       ? [defaultRender(empty(), 'empty')]

package/src/components/ForeignComponentContainer.tsx

@@ -0,0 +1,69 @@
+import * as React from 'react';
+import { isfunc } from 'piral-base';
+import { __RouterContext } from 'react-router';
+import { ForeignComponent, BaseComponentProps, ComponentContext } from '../types';
+
+interface ForeignComponentContainerProps<T> {
+  $portalId: string;
+  $component: ForeignComponent<T>;
+  $context: ComponentContext;
+  innerProps: T & BaseComponentProps;
+}
+
+export class ForeignComponentContainer<T> extends React.Component<ForeignComponentContainerProps<T>> {
+  private current?: HTMLElement;
+  private previous?: HTMLElement;
+  private handler = (ev: CustomEvent) => {
+    const { innerProps } = this.props;
+    ev.stopPropagation();
+    innerProps.piral.renderHtmlExtension(ev.detail.target, ev.detail.props);
+  };
+
+  private setNode = (node: HTMLDivElement) => {
+    this.current = node;
+  };
+
+  componentDidMount() {
+    const node = this.current;
+    const { $component, $context, innerProps } = this.props;
+    const { mount } = $component;
+
+    if (node && isfunc(mount)) {
+      mount(node, innerProps, $context);
+      node.addEventListener('render-html', this.handler, false);
+    }
+
+    this.previous = node;
+  }
+
+  componentDidUpdate() {
+    const { current, previous } = this;
+    const { $component, $context, innerProps } = this.props;
+    const { update } = $component;
+
+    if (current !== previous) {
+      previous && this.componentWillUnmount();
+      current && this.componentDidMount();
+    } else if (isfunc(update)) {
+      update(current, innerProps, $context);
+    }
+  }
+
+  componentWillUnmount() {
+    const node = this.previous;
+    const { $component } = this.props;
+    const { unmount } = $component;
+
+    if (node && isfunc(unmount)) {
+      unmount(node);
+      node.removeEventListener('render-html', this.handler, false);
+    }
+
+    this.previous = undefined;
+  }
+
+  render() {
+    const { $portalId } = this.props;
+    return <div data-portal-id={$portalId} ref={this.setNode} />;
+  }
+}

package/src/components/index.ts

@@ -18,3 +18,4 @@ export * from './SetProvider';
 export * from './SetRedirect';
 export * from './SetRoute';
 export * from './SwitchErrorInfo';
+export * from './wrapComponent';

package/src/components/wrapComponent.tsx

@@ -0,0 +1,74 @@
+import * as React from 'react';
+import { __RouterContext } from 'react-router';
+import { PortalRenderer } from './PortalRenderer';
+import { ForeignComponentContainer } from './ForeignComponentContainer';
+import { useGlobalStateContext } from '../hooks';
+import { convertComponent, none } from '../utils';
+import { AnyComponent, ComponentConverters, ForeignComponent, PiletApi, BaseComponentProps } from '../types';
+
+// this is an arbitrary start number to have 6 digits
+let portalIdBase = 123456;
+
+interface CapturedProps {
+  piral: PiletApi;
+}
+
+function wrapReactComponent<T>(
+  Component: React.ComponentType<T & BaseComponentProps>,
+  captured: CapturedProps,
+  Wrapper: React.FC<T>,
+): React.ComponentType<T> {
+  return (props: T) => (
+    <Wrapper {...props}>
+      <Component {...props} {...captured} />
+    </Wrapper>
+  );
+}
+
+function wrapForeignComponent<T>(
+  component: ForeignComponent<T & BaseComponentProps>,
+  captured: CapturedProps,
+  Wrapper: React.FC<T>,
+) {
+  return React.memo((props: T) => {
+    const { state, readState, destroyPortal } = useGlobalStateContext();
+    const router = React.useContext(__RouterContext);
+    const id = React.useMemo(() => (portalIdBase++).toString(26), none);
+    const context = React.useMemo(() => ({ router, state, readState }), [router, state]);
+    const innerProps = React.useMemo(() => ({ ...props, ...captured }), [props]);
+
+    React.useEffect(() => () => destroyPortal(id), none);
+
+    return (
+      <Wrapper {...props}>
+        <PortalRenderer id={id} />
+        <ForeignComponentContainer innerProps={innerProps} $portalId={id} $component={component} $context={context} />
+      </Wrapper>
+    );
+  });
+}
+
+function isNotExotic(component: any): component is object {
+  return !(component as React.ExoticComponent).$$typeof;
+}
+
+export function wrapComponent<T>(
+  converters: ComponentConverters<T & BaseComponentProps>,
+  component: AnyComponent<T & BaseComponentProps>,
+  captured: CapturedProps,
+  Wrapper: React.FC<T>,
+) {
+  if (!component) {
+    const pilet = captured.piral.meta.name;
+    console.error(`[${pilet}] The given value is not a valid component.`);
+    // tslint:disable-next-line:no-null-keyword
+    component = () => null;
+  }
+
+  if (typeof component === 'object' && isNotExotic(component)) {
+    const result = convertComponent(converters[component.type], component);
+    return wrapForeignComponent<T>(result, captured, Wrapper);
+  }
+
+  return wrapReactComponent<T>(component, captured, Wrapper);
+}

package/src/createInstance.tsx

@@ -49,7 +49,7 @@ export function createInstance(config: PiralInstanceOptions = {}): PiralInstance
   const usedPlugins = Array.isArray(definedPlugins) ? definedPlugins : [definedPlugins];
   const createApi = apiFactory(context, usedPlugins);
   const root = createApi({
-    name: 'root',
+    name: '_',
     version: process.env.BUILD_PCKG_VERSION || '1.0.0',
     spec: 'v0',
     basePath: '',

package/src/debugger.ts

@@ -3,7 +3,7 @@ import { LoadPiletsOptions } from 'piral-base';
 import { installPiralDebug, DebuggerExtensionOptions } from 'piral-debug-utils';
 import { GlobalStateContext } from './types';
 
-export function integrate(
+export function integrateDebugger(
   context: GlobalStateContext,
   options: LoadPiletsOptions,
   debug: DebuggerExtensionOptions = {},

package/src/emulator.ts

@@ -2,7 +2,7 @@ import { LoadPiletsOptions } from 'piral-base';
 import { withEmulatorPilets } from 'piral-debug-utils';
 import { GlobalStateContext } from './types';
 
-export function integrate(context: GlobalStateContext, options: LoadPiletsOptions) {
+export function integrateEmulator(context: GlobalStateContext, options: LoadPiletsOptions) {
   options.fetchPilets = withEmulatorPilets(options.fetchPilets, {
     addPilet: context.addPilet,
     removePilet: context.removePilet,

package/src/helpers.tsx

@@ -8,9 +8,10 @@ import {
   PiletLoader,
   PiletLifecycleHooks,
 } from 'piral-base';
-import { DebuggerExtensionOptions } from 'piral-debug-utils';
+import type { DebuggerExtensionOptions } from 'piral-debug-utils';
 import { globalDependencies } from './modules';
 import type { Pilet, PiletRequester, GlobalStateContext, PiletLoadingStrategy, DependencySelector } from './types';
+import { integrateDebugger, integrateEmulator } from '../debug.codegen';
 
 export interface PiletOptionsConfig {
   context: GlobalStateContext;
@@ -50,17 +51,8 @@ export function createPiletOptions({
     dependencies: shareDependencies(globalDependencies),
   };
 
-  // if we build the debug version of piral (debug and emulator build)
-  if (process.env.DEBUG_PIRAL) {
-    const { integrate } = require('./debugger');
-    integrate(context, options, debug);
-  }
-
-  // if we build the emulator version of piral (shipped to pilets)
-  if (process.env.DEBUG_PILET) {
-    const { integrate } = require('./emulator');
-    integrate(context, options);
-  }
+  integrateDebugger(context, options, debug);
+  integrateEmulator(context, options, debug);
 
   return options;
 }

package/src/modules/dependencies.ts

@@ -1,6 +1,6 @@
 import { isfunc } from 'piral-base';
-import { __assign } from 'tslib';
 import type { AvailableDependencies, PiletEntries } from '../types';
+import fillDependencies from '../../dependencies.codegen';
 
 /**
  * The global dependencies, which represent the dependencies
@@ -8,27 +8,8 @@ import type { AvailableDependencies, PiletEntries } from '../types';
  */
 export const globalDependencies: AvailableDependencies = {};
 
-if (process.env.SHARED_DEPENDENCIES) {
-  const fillDependencies = require('../../dependencies.codegen');
-
-  if (isfunc(fillDependencies)) {
-    fillDependencies(globalDependencies);
-  } else {
-    // fall back to the default list if the codegen is invalid / not supported
-    __assign(globalDependencies, {
-      react: require('react'),
-      'react-dom': require('react-dom'),
-      'react-router': require('react-router'),
-      'react-router-dom': require('react-router-dom'),
-      history: require('history'),
-      tslib: require('tslib'),
-      'path-to-regexp': require('path-to-regexp'),
-      '@libre/atom': require('@libre/atom'),
-      '@dbeining/react-atom': require('@dbeining/react-atom'),
-    });
-  }
-} else {
-  // App shell is built with something else than the Piral CLI - just don't fill ...
+if (isfunc(fillDependencies)) {
+  fillDependencies(globalDependencies);
 }
 
 /**

package/src/state/withApi.tsx

@@ -1,147 +1,11 @@
 import * as React from 'react';
-import { isfunc } from 'piral-base';
 import { __RouterContext } from 'react-router';
-import { ErrorBoundary, PortalRenderer } from '../components';
-import { useGlobalStateContext } from '../hooks';
-import { defaultRender, convertComponent, none } from '../utils';
-import {
-  AnyComponent,
-  Errors,
-  ComponentConverters,
-  ForeignComponent,
-  PiletApi,
-  BaseComponentProps,
-  ComponentContext,
-  GlobalStateContext,
-} from '../types';
-
-// this is an arbitrary start number to have 6 digits
-let portalIdBase = 123456;
+import { ErrorBoundary, wrapComponent } from '../components';
+import { defaultRender } from '../utils';
+import { AnyComponent, Errors, PiletApi, BaseComponentProps, GlobalStateContext } from '../types';
 
 const DefaultWrapper: React.FC = (props) => defaultRender(props.children);
 
-interface CapturedProps {
-  piral: PiletApi;
-}
-
-interface ForeignComponentContainerProps<T> {
-  $portalId: string;
-  $component: ForeignComponent<T>;
-  $context: ComponentContext;
-  innerProps: T & BaseComponentProps;
-}
-
-class ForeignComponentContainer<T> extends React.Component<ForeignComponentContainerProps<T>> {
-  private current?: HTMLElement;
-  private previous?: HTMLElement;
-  private handler = (ev: CustomEvent) => {
-    const { innerProps } = this.props;
-    ev.stopPropagation();
-    innerProps.piral.renderHtmlExtension(ev.detail.target, ev.detail.props);
-  };
-
-  private setNode = (node: HTMLDivElement) => {
-    this.current = node;
-  };
-
-  componentDidMount() {
-    const node = this.current;
-    const { $component, $context, innerProps } = this.props;
-    const { mount } = $component;
-
-    if (node && isfunc(mount)) {
-      mount(node, innerProps, $context);
-      node.addEventListener('render-html', this.handler, false);
-    }
-
-    this.previous = node;
-  }
-
-  componentDidUpdate() {
-    const { current, previous } = this;
-    const { $component, $context, innerProps } = this.props;
-    const { update } = $component;
-
-    if (current !== previous) {
-      previous && this.componentWillUnmount();
-      current && this.componentDidMount();
-    } else if (isfunc(update)) {
-      update(current, innerProps, $context);
-    }
-  }
-
-  componentWillUnmount() {
-    const node = this.previous;
-    const { $component } = this.props;
-    const { unmount } = $component;
-
-    if (node && isfunc(unmount)) {
-      unmount(node);
-      node.removeEventListener('render-html', this.handler, false);
-    }
-
-    this.previous = undefined;
-  }
-
-  render() {
-    const { $portalId } = this.props;
-    return <div data-portal-id={$portalId} ref={this.setNode} />;
-  }
-}
-
-function wrapReactComponent<T>(
-  Component: React.ComponentType<T & BaseComponentProps>,
-  captured: CapturedProps,
-  Wrapper: React.FC<T>,
-): React.ComponentType<T> {
-  return (props: T) => (
-    <Wrapper {...props}>
-      <Component {...props} {...captured} />
-    </Wrapper>
-  );
-}
-
-function wrapForeignComponent<T>(
-  component: ForeignComponent<T & BaseComponentProps>,
-  captured: CapturedProps,
-  Wrapper: React.FC<T>,
-) {
-  return React.memo((props: T) => {
-    const { state, readState, destroyPortal } = useGlobalStateContext();
-    const router = React.useContext(__RouterContext);
-    const id = React.useMemo(() => (portalIdBase++).toString(26), none);
-    const context = React.useMemo(() => ({ router, state, readState }), [router, state]);
-    const innerProps = React.useMemo(() => ({ ...props, ...captured }), [props]);
-
-    React.useEffect(() => () => destroyPortal(id), none);
-
-    return (
-      <Wrapper {...props}>
-        <PortalRenderer id={id} />
-        <ForeignComponentContainer innerProps={innerProps} $portalId={id} $component={component} $context={context} />
-      </Wrapper>
-    );
-  });
-}
-
-function isNotExotic(component: any): component is object {
-  return !(component as React.ExoticComponent).$$typeof;
-}
-
-function wrapComponent<T>(
-  converters: ComponentConverters<T & BaseComponentProps>,
-  component: AnyComponent<T & BaseComponentProps>,
-  captured: CapturedProps,
-  Wrapper: React.FC<T>,
-) {
-  if (typeof component === 'object' && isNotExotic(component)) {
-    const result = convertComponent(converters[component.type], component);
-    return wrapForeignComponent<T>(result, captured, Wrapper);
-  }
-
-  return wrapReactComponent<T>(component, captured, Wrapper);
-}
-
 function getWrapper(wrappers: Record<string, React.ComponentType<any>>, wrapperType: string) {
   const WrapAll = wrappers['*'];
   const WrapType = wrappers[wrapperType];
@@ -157,32 +21,33 @@ function getWrapper(wrappers: Record<string, React.ComponentType<any>>, wrapperT
   return WrapType || WrapAll || DefaultWrapper;
 }
 
-export function withApi<TProps>(
+function makeWrapper<TProps>(
   context: GlobalStateContext,
-  component: AnyComponent<TProps & BaseComponentProps>,
-  piral: PiletApi,
+  outerProps: any,
+  wrapperType: string,
   errorType: keyof Errors,
-  wrapperType: string = errorType,
-  captured = {},
-) {
-  const outerProps = { ...captured, piral };
-  const converters = context.converters;
+): React.FC<TProps> {
   const OuterWrapper = context.readState((m) => getWrapper(m.registry.wrappers, wrapperType));
 
-  const Wrapper: React.FC<TProps> = (props) => (
+  return (props) => (
     <OuterWrapper {...outerProps} {...props}>
       <ErrorBoundary {...outerProps} {...props} errorType={errorType}>
         {props.children}
       </ErrorBoundary>
     </OuterWrapper>
   );
+}
 
-  if (!component) {
-    const pilet = piral.meta.name;
-    console.error(`[${pilet}] The given value is not a valid component.`);
-    // tslint:disable-next-line:no-null-keyword
-    component = () => null;
-  }
-
-  return wrapComponent<TProps>(converters, component, outerProps, Wrapper);
+export function withApi<TProps>(
+  context: GlobalStateContext,
+  component: AnyComponent<TProps & BaseComponentProps>,
+  piral: PiletApi,
+  errorType: keyof Errors,
+  wrapperType: string = errorType,
+  captured = {},
+) {
+  const outerProps = { ...captured, piral };
+  const converters = context.converters;
+  const Wrapper = makeWrapper<TProps>(context, outerProps, wrapperType, errorType);
+  return wrapComponent(converters, component, outerProps, Wrapper);
 }

package/src/types/api.ts

@@ -12,7 +12,7 @@ import type {
 } from 'piral-base';
 import type { PiletCustomApi, PiralCustomPageMeta } from './custom';
 import type { AnyComponent } from './components';
-import type { ExtensionSlotProps, PiralExtensionSlotMap } from './extension';
+import type { ExtensionParams, ExtensionSlotProps, PiralExtensionSlotMap } from './extension';
 import type { SharedData, DataStoreOptions } from './data';
 import type { Disposable } from './utils';
 
@@ -113,7 +113,7 @@ export interface PiletCoreApi {
   registerExtension<TName>(
     name: TName extends string ? TName : string,
     Component: AnyComponent<ExtensionComponentProps<TName>>,
-    defaults?: TName,
+    defaults?: Partial<ExtensionParams<TName>>,
   ): RegistrationDisposer;
   /**
    * Unregisters a global extension component.

package/src/types/extension.ts

@@ -34,10 +34,19 @@ export interface BaseExtensionSlotProps<TName, TParams> {
   name: TName;
 }
 
+/**
+ * Gives the extension params shape for the given extension slot name.
+ */
+export type ExtensionParams<TName> = TName extends keyof PiralExtensionSlotMap
+  ? PiralExtensionSlotMap[TName]
+  : TName extends string
+  ? any
+  : TName;
+
 /**
  * The props for defining an extension slot.
  */
-export type ExtensionSlotProps<K = string> = BaseExtensionSlotProps<
-  K extends string ? K : string,
-  K extends keyof PiralExtensionSlotMap ? PiralExtensionSlotMap[K] : K extends string ? any : K
+export type ExtensionSlotProps<TName = string> = BaseExtensionSlotProps<
+  TName extends string ? TName : string,
+  ExtensionParams<TName>
 >;