@plurid/plurid-data 0.0.0-2 → 0.0.0-20

package/distribution/interfaces/external/router/index.d.ts

@@ -1,16 +1,18 @@
-import { PluridComponent } from "../component/index";
-import { PluridPartialConfiguration } from "../configuration/index";
-import { CompareType } from "../compare/index";
-export interface PluridRouterProperties {
-    routes: PluridRoute[];
+import { PluridRoute, PluridRoutePlane } from './route';
+export interface PluridRouterProperties<C> {
+    routes: PluridRoute<C>[];
+    /**
+     * Plurid planes not specific to any route.
+     */
+    planes?: PluridRoutePlane<C>[];
     /**
      * Component to be rendered outside of the current `path` component and of the `shell`.
      */
-    exterior?: PluridComponent;
+    exterior?: C;
     /**
      * Component to wrap around the current path component.
      */
-    shell?: PluridComponent;
+    shell?: C;
     /**
      * Path to navigate to when using clean navigation.
      */
@@ -25,11 +27,9 @@ export interface PluridRouterProperties {
      */
     protocol?: string;
     /**
-     * Development default: `'localhost:3000'`.
-     *
-     * Production default: `window.location.host`.
+     * Default: `'origin'` | `window.location.host`.
      */
-    host?: string;
+    hostname?: string;
     /**
      * The `gatewayPath` is used to receive external routing requests.
      *
@@ -45,7 +45,7 @@ export interface PluridRouterProperties {
     /**
      * Component to be rendered on the gateway path, external to the plurid view.
      */
-    gatewayExterior?: PluridComponent;
+    gatewayExterior?: C;
     /**
      * Redirect not found paths to this path.
      * Default: `/not-found`.
@@ -55,210 +55,29 @@ export interface PluridRouterProperties {
      * API endpoint to request the elements for the paths not found in the initial routing.
      */
     api?: string;
-    static?: any;
-}
-export interface PluridRouterStatic {
-    path: string;
-}
-/**
- * A route can be `plurid space` or `exterior`-based.
- */
-export interface PluridRoute {
-    /**
-     * The route `value` can:
-     * + be a simple string, e.g. `'/route/to/page'`;
-     * + be a parametric location, e.g. `'/route/to/:page'`, where `:page` is the parameter name;
-     * + receive query `key=value` pairs,
-     * e.g. `'/route/to/page?id=1&show=true'`, where `id=1` and `show=true` are `key=value` pairs;
-     */
-    value: string;
-    parameters?: Record<string, PluridRouteParameter>;
+    static?: PluridRouterStatic;
     /**
-     * Accepts a component which will be rendered outside of the `spaces`.
+     * Replace the internal plurid plane with a custom implementation.
      */
-    exterior?: PluridComponent;
+    customPlane?: C;
     /**
-     * A path can have planes and/or spaces.
+     * After router navigation scroll to the top.
      *
-     * Planes will be assigned to the `default` space, `default` universe, `default` cluster.
+     * Default: `smooth`.
      */
-    planes?: PluridRoutePlane[];
-    view?: string[];
+    scrollToTop?: boolean | 'instant' | 'smooth';
     /**
-     * A path can have planes and/or spaces.
-     */
-    spaces?: PluridRouteSpace[];
-    /**
-     * Pass the rendered `spaces[]` components as a property to the `exterior` component
-     * to be rendered in particular slots.
-     */
-    slotted?: boolean;
-    multispace?: PluridRouteMultispace;
-    defaultConfiguration?: PluridPartialConfiguration;
-}
-export interface PluridPreserve<C = undefined> {
-    /**
-     * Served path value.
-     */
-    serve: string;
-    /**
-     * The function will be executed and awaited before rendering the application on the server.
+     * Fade in from black, in milliseconds.
      *
-     * The function can return one or more providers which will be passed to their appropriate consumers,
-     * can redirect to a different path, or can handle any cross-cutting concerns, such as eventing or logging.
-     */
-    onServe: PluridPreserveOnServe<C>;
-    /**
-     * Function called after route is served successfully.
-     */
-    afterServe?: PluridPreserveAfterServe<C>;
-    /**
-     * Function called if `onServe` throws an error.
+     * Default: `10`
      */
-    onError?: PluridPreserveOnError<C>;
+    fadeIn?: number;
 }
-export declare type PluridPreserveOnServe<C> = (transmission: PluridPreserveTransmission<C | undefined>) => Promise<PluridPreserveResponse | void>;
-export declare type PluridPreserveAfterServe<C> = (transmission: PluridPreserveTransmission<C | undefined>) => Promise<void>;
-export declare type PluridPreserveOnError<C> = (error: any, transmission: PluridPreserveTransmission<C | undefined>) => Promise<PluridPreserveResponse | void>;
-export interface PluridPreserveTransmission<C = undefined> {
-    request: any;
-    response: any;
-    context: PluridPreserveTransmissionContext<C>;
-}
-export interface PluridPreserveTransmissionContext<C = undefined> {
+export interface PluridRouterStatic {
     path: string;
-    /** URL Router `MatchedRoute` */
-    match: {
-        target: string;
-        source: string;
-        elements: any;
-        parameters?: Record<string, string>;
-    };
-    contextualizers: C;
-}
-export interface PluridPreserveResponse {
-    providers?: PluridPreserveResponseProviders;
-    /**
-     * Redirect to another route.
-     */
-    redirect?: string;
-    /**
-     * If `response` is handled within the preserve `action`, set the `responded` value to `true`,
-     * to prevent the server from sending a double response.
-     */
-    responded?: boolean;
-    /**
-     * Handle the server response without taking into account the preserve.
-     * Considers only the first match.
-     */
-    depreserve?: boolean;
-    /**
-     * Ignore the preserve computation, but continue to try to find a match in the preserves array.
-     * To be used with the catch-all matcher `'*'` or with complex routing with overlapping parameters.
-     */
-    pass?: boolean;
-}
-export interface PluridPreserveResponseProviders {
-    apollo?: any;
-    redux?: any;
-    plurid?: any;
-}
-export interface PluridRouteParameter {
-    /**
-     * Constrain the path parameter to be of a certain length.
-     */
-    length?: number;
-    /**
-     * Ensure that the `length` of the path is of a certain type:
-     *
-     * * `'=='`     - equal,
-     * * `'<='`     - equal or less than,
-     * * `'<'`      - less than,
-     * * `'>='`     - equal or greater than,
-     * * `'>'`      - greater than.
-     *
-     * Default `'<='`, if a `length` is provided.
-     */
-    lengthType?: CompareType;
-    startsWith?: string;
-    endsWith?: string;
-    includes?: string[];
-}
-export interface PluridRouteSpace {
-    value: string;
-    /**
-     * Accepts a component which will be rendered outside of the `space`.
-     */
-    exterior?: PluridComponent;
-    /**
-     * A space can have planes and/or universes.
-     *
-     * Planes will be assigned to the `default` universe, `default` cluster.
-     */
-    planes?: PluridRoutePlane[];
-    view?: string[];
-    /**
-     * A space can have planes and/or universes.
-     */
-    universes?: PluridRouteUniverse[];
-    configuration?: PluridPartialConfiguration;
-}
-export interface PluridRouteUniverse {
-    value: string;
-    /**
-     * An universe can have planes and/or clusters.
-     *
-     * Planes will be assigned to the `default` cluster.
-     */
-    planes?: PluridRoutePlane[];
-    clusters?: PluridRouteCluster[];
-}
-export interface PluridRouteCluster {
-    value: string;
-    planes: PluridRoutePlane[];
-}
-export interface PluridRoutePlane {
-    component: PluridComponent;
-    value: string;
-    /**
-     * Map a direct link for a specific plane.
-     *
-     * e.g. `/plane-one` will route in browser the path `protocol://host/plane-one`
-     */
-    link?: string;
-    /**
-     * On direct link access, show the plane in a `plurid` space,
-     * or as the legacy view of an web page.
-     */
-    linkView?: 'legacy' | 'plurid';
-}
-export interface PluridRouteMultispace {
-    /**
-     * Default: `y`.
-     */
-    alignment?: 'x' | 'y';
-    /**
-     * Default: `mandatory`.
-     */
-    snapType?: 'none' | 'mandatory' | 'proximity';
-    header?: PluridComponent;
-    footer?: PluridComponent;
-}
-export interface PluridRouteFragments {
-    texts: PluridRouteFragmentText[];
-    elements: PluridRouteFragmentElement[];
-}
-export interface PluridRouteFragment {
-    type: string;
-}
-export interface PluridRouteFragmentText extends PluridRouteFragment {
-    type: 'text';
-    start: string;
-    end: string;
-    occurence: number;
-}
-export interface PluridRouteFragmentElement extends PluridRouteFragment {
-    type: 'element';
-    id: string;
-    occurence: number;
+    directPlane?: string;
 }
+export * from './fragment';
+export * from './multispace';
+export * from './preserve';
+export * from './route';

package/distribution/interfaces/external/router/multispace/index.d.ts

@@ -0,0 +1,14 @@
+export declare type PluridRouteMultispaceAlignment = 'x' | 'y';
+export declare type PluridRouteMultispaceSnapType = 'none' | 'mandatory' | 'proximity';
+export interface PluridRouteMultispace<C> {
+    /**
+     * Default: `y`.
+     */
+    alignment?: PluridRouteMultispaceAlignment;
+    /**
+     * Default: `mandatory`.
+     */
+    snapType?: PluridRouteMultispaceSnapType;
+    header?: C;
+    footer?: C;
+}

package/distribution/interfaces/external/router/preserve/index.d.ts

@@ -0,0 +1,70 @@
+export interface PluridPreserve<M = any, RQ = any, RS = any> {
+    /**
+     * Served path value.
+     */
+    serve: string;
+    /**
+     * The function will be executed and awaited before rendering the application on the server.
+     *
+     * The function can return one or more providers which will be passed to their appropriate consumers,
+     * can redirect to a different path, or can handle any cross-cutting concerns, such as eventing or logging.
+     */
+    onServe: PluridPreserveOnServe<M, RQ, RS>;
+    /**
+     * Function called after route is served successfully.
+     */
+    afterServe?: PluridPreserveAfterServe<M, RQ, RS>;
+    /**
+     * Function called if `onServe` throws an error.
+     */
+    onError?: PluridPreserveOnError<M, RQ, RS>;
+}
+export declare type PluridPreserveOnServe<M, RQ, RS> = (transmission: PluridPreserveTransmission<M, RQ, RS>) => Promise<PluridPreserveResponse | undefined>;
+export declare type PluridPreserveAfterServe<M, RQ, RS> = (transmission: PluridPreserveTransmission<M, RQ, RS>) => Promise<undefined>;
+export declare type PluridPreserveOnError<M, RQ, RS> = (error: any, transmission: PluridPreserveTransmission<M, RQ, RS>) => Promise<PluridPreserveResponse | undefined>;
+export interface PluridPreserveTransmission<M, RQ, RS> {
+    context: PluridPreserveTransmissionContext<M>;
+    request: RQ;
+    response: RS;
+}
+export interface PluridPreserveTransmissionContext<M = undefined> {
+    match: M;
+    route: string;
+}
+export interface PluridPreserveResponse {
+    providers?: PluridPreserveResponseProviders;
+    /**
+     * Redirect to another route.
+     */
+    redirect?: string;
+    /**
+     * If `response` is handled within the preserve `action`, set the `responded` value to `true`,
+     * to prevent the server from sending a double response.
+     */
+    responded?: boolean;
+    /**
+     * Handle the server response without taking into account the preserve.
+     * Considers only the first match.
+     */
+    depreserve?: boolean;
+    /**
+     * Ignore the preserve computation, but continue to try to find a match in the preserves array.
+     * To be used with the catch-all matcher `'*'` or with complex routing with overlapping parameters.
+     */
+    pass?: boolean;
+    /**
+     * Key-value pairs which will be inserted as globals on the window as in
+     * `window.${key} = ${value}`.
+     */
+    globals?: Record<string, string>;
+    template?: PluridPreserveResponseTemplate;
+}
+export declare type PluridPreserveResponseProviders = Record<string, any>;
+export interface PluridPreserveResponseTemplate {
+    htmlLanguage?: string;
+    htmlAttributes?: Record<string, string>;
+    bodyAttributes?: Record<string, string>;
+    headScripts?: string[];
+    bodyScripts?: string[];
+    styles?: string[];
+}

package/distribution/interfaces/external/router/route/index.d.ts

@@ -0,0 +1,171 @@
+import { PluridPartialConfiguration } from "../../configuration";
+import { CompareType } from "../../compare";
+import { PluridRouteMultispace } from '../multispace';
+export declare type PluridRouteResolver<C> = Omit<PluridRoute<C>, 'value' | 'resolver'>;
+/**
+ * A route can be `plurid space` or `exterior`-based.
+ */
+export interface PluridRoute<C, G = any> {
+    /**
+     * The route `value` can:
+     * + be a simple string, e.g. `'/route/to/page'`;
+     * + be a parametric location, e.g. `'/route/to/:page'`, where `:page` is the parameter name;
+     * + receive query `key=value` pairs,
+     * e.g. `'/route/to/page?id=1&show=true'`, where `id=1` and `show=true` are `key=value` pairs;
+     */
+    value: string;
+    parameters?: Record<string, PluridRouteParameter>;
+    /**
+     * Accepts a component which will be rendered outside of the `spaces`.
+     */
+    exterior?: C;
+    /**
+     * A route can have planes and/or spaces.
+     */
+    planes?: PluridRoutePlane<C>[];
+    view?: string[];
+    /**
+     * A route can have planes and/or spaces.
+     */
+    spaces?: PluridRouteSpace<C>[];
+    /**
+     * Pass the rendered `spaces[]` components as a property to the `exterior` component
+     * to be rendered in particular slots.
+     */
+    slotted?: boolean;
+    multispace?: PluridRouteMultispace<C>;
+    defaultConfiguration?: PluridPartialConfiguration;
+    /**
+     * Resolve the route at request time.
+     *
+     * Receives the `globals` from the preserve, if any.
+     */
+    resolver?: (globals: G | undefined) => PluridRouteResolver<C> | Promise<PluridRouteResolver<C>>;
+}
+export interface PluridRouteParameter {
+    /**
+     * Constrain the route parameter to be of a certain length.
+     */
+    length?: number;
+    /**
+     * Ensure that the `length` of the route parameter is of a certain type:
+     *
+     * * `'=='`     - equal,
+     * * `'<='`     - equal or less than,
+     * * `'<'`      - less than,
+     * * `'>='`     - equal or greater than,
+     * * `'>'`      - greater than.
+     *
+     * Default `'<='`, if a `length` is provided.
+     */
+    lengthType?: CompareType;
+    startsWith?: string;
+    endsWith?: string;
+    includes?: string[];
+}
+export interface PluridRouteSpace<C> {
+    value: string;
+    /**
+     * Accepts a component which will be rendered outside of the `space`.
+     */
+    exterior?: C;
+    /**
+     * A space can have planes and/or universes.
+     */
+    planes?: PluridRoutePlane<C>[];
+    view?: string[];
+    /**
+     * A space can have planes and/or universes.
+     */
+    universes?: PluridRouteUniverse<C>[];
+    configuration?: PluridPartialConfiguration;
+}
+export interface PluridRouteUniverse<C> {
+    value: string;
+    planes?: PluridRoutePlane<C>[];
+    view?: string[];
+    /**
+     * By default, the order the documents are shown in is based on their index in the `documents[]`.
+     * The ordinal can be used to overrule the default order.
+     * If not unique, the documents with equal `ordinal` will be ordered by index.
+     *
+     * 0-based.
+     */
+    ordinal?: number;
+    /**
+     * Set the document as active. By default the first document is active.
+     *
+     * Only one document can be active at a time.
+     */
+    active?: boolean;
+}
+export interface PluridRoutePlaneOptions {
+    /**
+     * Map a direct link for a specific plane.
+     *
+     * e.g. `/plane-one` will route in browser the path `protocol://host/plane-one`
+     *
+     * Default composed from route and plane value, `/<route.value/<plane.value>`
+     */
+    link?: string;
+    /**
+     * On direct link access (from the browser), show the plane in a `plurid` space,
+     * or as the legacy view of an web page.
+     *
+     * Default `'plurid'`
+     */
+    linkView?: 'legacy' | 'plurid';
+    /**
+     * Injectable into other `plurid` spaces.
+     *
+     * Default `true`
+     */
+    injectable?: boolean;
+    /**
+     * Direct access to the plane from the browser.
+     *
+     * Default plane link composed from route and plane value, `/<route.value/<plane.value>`;
+     * changeable through the `link` property.
+     *
+     * Default `true`
+     */
+    urlable?: boolean;
+    /**
+     * Access to the plane through the `gateway` path.
+     *
+     * Default `true`
+     */
+    gateable?: boolean;
+    /**
+     * Render route exterior when directly accessed.
+     *
+     * Default `true`
+     */
+    directExterior?: boolean;
+    /**
+     * Render route exterior when injected into other `plurid` space.
+     *
+     * Default `false`
+     */
+    injectExterior?: boolean;
+    /**
+     * Constraints for the parameters.
+     */
+    parameters?: Record<string, PluridRouteParameter>;
+}
+export interface PluridRoutePlaneObject<C> extends PluridRoutePlaneOptions {
+    value: string;
+    component: C;
+}
+export declare type PluridRoutePlaneTuple<C> = [
+    /**
+     * See `PluridRoutePlaneObject<C>.value`.
+     */
+    value: string,
+    /**
+     * See `PluridRoutePlaneObject<C>.component`.
+     */
+    component: C,
+    options?: PluridRoutePlaneOptions
+];
+export declare type PluridRoutePlane<C> = PluridRoutePlaneObject<C> | PluridRoutePlaneTuple<C>;

package/distribution/interfaces/external/routing/index.d.ts

@@ -0,0 +1,58 @@
+import { PluridRoute, PluridRoutePlane, PluridRoutePlaneObject, PluridRouteFragments } from '../router';
+import { PluridPlane, PluridPlaneObject } from '../plane';
+export interface IsoMatcherData<C> {
+    routes?: PluridRoute<C>[];
+    routePlanes?: PluridRoutePlane<C>[];
+    planes?: PluridPlane<C>[];
+}
+export declare type IsoMatcherContext = 'route' | 'plane';
+export interface IsoMatcherResultBase {
+    value: string;
+    parameters: Record<string, string>;
+    query: Record<string, string>;
+}
+export interface IsoMatcherRouteResultBase {
+    match: IsoMatcherResultBase;
+}
+export interface IsoMatcherRouteResultRoute<C> extends IsoMatcherRouteResultBase {
+    kind: 'Route';
+    data: PluridRoute<C>;
+}
+export interface IsoMatcherRouteResultRoutePlane<C> extends IsoMatcherRouteResultBase {
+    kind: 'RoutePlane';
+    data: PluridRoutePlaneObject<C>;
+}
+export declare type IsoMatcherRouteResult<C> = IsoMatcherRouteResultRoute<C> | IsoMatcherRouteResultRoutePlane<C>;
+export interface IsoMatcherIndexedRoute<C> {
+    data: PluridRoute<C>;
+}
+export declare type IsoMatcherPlaneType = 'Plane' | 'RoutePlane';
+export interface IsoMatcherPlaneResultMatch extends IsoMatcherResultBase {
+    fragments: PluridRouteFragments;
+}
+export interface IsoMatcherPlaneResultBase<C> {
+    parent?: string;
+    match: IsoMatcherPlaneResultMatch;
+}
+export interface IsoMatcherPlaneResultPlane<C> extends IsoMatcherPlaneResultBase<C> {
+    kind: 'Plane';
+    data: PluridPlaneObject<C>;
+}
+export interface IsoMatcherPlaneResultRoutePlane<C> extends IsoMatcherPlaneResultBase<C> {
+    kind: 'RoutePlane';
+    data: PluridRoutePlaneObject<C>;
+}
+export declare type IsoMatcherPlaneResult<C> = IsoMatcherPlaneResultPlane<C> | IsoMatcherPlaneResultRoutePlane<C>;
+export declare type IsoMatcherResult<C> = IsoMatcherRouteResult<C> | IsoMatcherPlaneResult<C>;
+export interface IsoMatcherIndexedPlaneBase<C> {
+    parent?: string;
+}
+export interface IsoMatcherIndexedPlanePlane<C> extends IsoMatcherIndexedPlaneBase<C> {
+    kind: 'Plane';
+    data: PluridPlaneObject<C>;
+}
+export interface IsoMatcherIndexedPlaneRoutePlane<C> extends IsoMatcherIndexedPlaneBase<C> {
+    kind: 'RoutePlane';
+    data: PluridRoutePlaneObject<C>;
+}
+export declare type IsoMatcherIndexedPlane<C> = IsoMatcherIndexedPlanePlane<C> | IsoMatcherIndexedPlaneRoutePlane<C>;

package/distribution/interfaces/external/universe/index.d.ts

@@ -1,16 +1,8 @@
-import { PluridPlane } from "../plane/index";
-import { PluridCluster } from "../cluster/index";
-import { PluridView } from "../view/index";
-export interface PluridUniverse {
-    /**
-     * Optional, application-wide unique identifier.
-     */
-    id?: string;
-    /**
-     * Must be unique if IDs not provided.
-     */
-    name: string;
-    planes: PluridPlane[];
+import { PluridPlane } from '../plane';
+export interface PluridUniverse<C> {
+    value: string;
+    planes?: PluridPlane<C>[];
+    view?: string[];
     /**
      * By default, the order the documents are shown in is based on their index in the `documents[]`.
      * The ordinal can be used to overrule the default order.
@@ -25,13 +17,4 @@ export interface PluridUniverse {
      * Only one document can be active at a time.
      */
     active?: boolean;
-    /**
-     * Paths to the pages in view on the initial rendering.
-     */
-    view?: string[] | PluridView[];
-    /**
-     * A cluster ensures the rendering of all the pages that it contains
-     * in the same space zone.
-     */
-    clusters?: PluridCluster[];
 }

package/distribution/interfaces/external/window/index.d.ts

@@ -1,4 +1,4 @@
-import { PluridPlanesRegistrar } from "../registrar/index";
-export declare type PluridalWindow = typeof window & {
-    __pluridPlanesRegistrar__: PluridPlanesRegistrar;
+import { PluridPlanesRegistrar } from '../registrar';
+export declare type PluridalWindow<C> = typeof window & {
+    __pluridPlanesRegistrar__: PluridPlanesRegistrar<C>;
 };

package/distribution/interfaces/index.d.ts

@@ -1,3 +1,3 @@
-export * from "./external/index";
-export * from "./internal/index";
-export * from "./helpers/index";
+export * from './external';
+export * from './internal';
+export * from './helpers';

package/distribution/interfaces/internal/context/index.d.ts

@@ -1,9 +1,16 @@
-import { PluridPlaneContext } from "../../external/plane/index";
-import { PluridPlanesRegistrar } from "../../external/registrar/index";
-import { PluridPubSub } from "../../external/pubsub/index";
-export interface PluridContext {
-    planesRegistrar?: PluridPlanesRegistrar;
+import { PluridPlaneContext } from "../../external/plane";
+import { PluridPlanesRegistrar } from "../../external/registrar";
+import { IsoMatcherRouteResult } from "../../external/routing";
+import { PluridPubSub } from "../../external/pubsub";
+export interface PluridContext<C> {
+    planesRegistrar?: PluridPlanesRegistrar<C>;
     planeContext?: PluridPlaneContext<any>;
     planeContextValue?: any;
+    customPlane?: C;
+    planeNotFound?: boolean | C;
+    planeRenderError?: boolean | C;
+    matchedRoute?: IsoMatcherRouteResult<C> | undefined;
+    hostname?: string;
+    defaultPubSub: PluridPubSub;
     registerPubSub: (pubsub: PluridPubSub) => void;
 }

package/distribution/interfaces/internal/index.d.ts

@@ -1,7 +1,5 @@
-export * from "./context/index";
-export * from "./internationalization/index";
-export * from "./plane/index";
-export * from "./shortcuts/index";
-export * from "./state/index";
-export * from "./tree/index";
-export * from "./universe/index";
+export * from './context';
+export * from './shortcuts';
+export * from './state';
+export * from './transform';
+export * from './tree';