@plurid/plurid-engine 0.0.0-1 → 0.0.0-12

package/distribution/modules/general/configuration/index.d.ts

@@ -0,0 +1,2 @@
+import { PluridPartialConfiguration, PluridConfiguration } from '@plurid/plurid-data';
+export declare const merge: (configuration?: PluridPartialConfiguration, target?: PluridConfiguration) => PluridConfiguration;

package/distribution/modules/general/index.d.ts

@@ -0,0 +1,3 @@
+import * as configuration from './configuration';
+import * as tree from './tree';
+export { configuration, tree, };

package/distribution/modules/{setup/general → general}/tree/index.d.ts

@@ -1,6 +1,6 @@
 import { 
 /** interfaces */
 PluridInternalContextPlane, PluridInternalStatePlane, TreePlane, LinkCoordinates } from '@plurid/plurid-data';
-export declare const createTreePlane: (contextPlane: PluridInternalContextPlane, documentPlane: PluridInternalStatePlane) => TreePlane;
+export declare const createTreePlane: <C>(contextPlane: PluridInternalContextPlane<C>, documentPlane: PluridInternalStatePlane) => TreePlane;
 export declare const updateTreePlane: (tree: TreePlane[], page: TreePlane) => TreePlane[];
 export declare const updateTreeByPlaneIDWithLinkCoordinates: (tree: TreePlane[], planeID: string, linkCoordinates: LinkCoordinates) => TreePlane[];

package/distribution/modules/index.d.ts

@@ -1,12 +1,9 @@
-import * as direction from "./interaction/direction/index";
-import internatiolate from "./setup/internationalization/index";
-import * as general from "./setup/general/index";
-import * as matrix from "./interaction/mathematics/matrix/index";
-import * as quaternion from "./interaction/mathematics/quaternion/index";
-import * as router from "./setup/router/index";
-import * as transform from "./interaction/mathematics/transform/index";
-import * as space from "./setup/space/index";
-import * as state from "./setup/state/index";
-import * as utilities from "./utilities/index";
-export { direction, internatiolate, general, matrix, quaternion, router, transform, space, state, utilities, };
-export * from "./setup/objects/PlanesRegistrar/index";
+import * as general from './general';
+import * as interaction from './interaction';
+import internatiolate from './internationalization';
+import * as planes from './planes';
+import * as routing from './routing';
+import * as space from './space';
+import * as state from './state';
+import * as utilities from './utilities';
+export { general, interaction, internatiolate, planes, routing, space, state, utilities, };

package/distribution/modules/interaction/direction/index.d.ts

@@ -1,2 +1,2 @@
-import { WheelDeltas } from "../../../data/interfaces/index";
+import { WheelDeltas } from '@plurid/plurid-data';
 export declare const getWheelDirection: (deltas: WheelDeltas, ABSTHRESHOLD?: number, THRESHOLD?: number) => string;

package/distribution/modules/interaction/index.d.ts

@@ -0,0 +1,5 @@
+import * as direction from './direction';
+import * as matrix from './mathematics/matrix';
+import * as quaternion from './mathematics/quaternion';
+import * as transform from './mathematics/transform';
+export { direction, matrix, quaternion, transform, };

package/distribution/modules/interaction/mathematics/transform/general/index.d.ts

@@ -0,0 +1,9 @@
+export declare type Matrix = number[][];
+export declare const multiplyMatrices: (m1: Matrix, m2: Matrix) => Matrix;
+export declare const arrayToMatrix: (array: number[]) => Matrix;
+export declare const matrixToArray: (matrix: Matrix) => number[];
+export declare const printMatrix: (matrix: Matrix, name: string) => void;
+export declare const rotateXMatrix: (angle: number) => Matrix;
+export declare const rotateYMatrix: (angle: number) => Matrix;
+export declare const rotateZMatrix: (angle: number) => Matrix;
+export declare const translateMatrix: (x?: number, y?: number, z?: number) => Matrix;

package/distribution/modules/interaction/mathematics/transform/index.d.ts

@@ -1,69 +1,3 @@
-/**
- * Converts the CSS string matrix3d into an array of numbers.
- *
- * @param matrix3d      CSS string obtained from
- *                      window
- *                          .getComputedStyle(element)
- *                          .getPropertyValue('transform').
- * @returns             Numbers array.
- */
-export declare function getMatrixValues(matrix3d: string): number[];
-/**
- * Extracts the rotation matrix from the matrix3d CSS string.
- *
- * @param matrix3d      CSS string obtained from
- *                      window
- *                          .getComputedStyle(element)
- *                          .getPropertyValue("transform").
- * @returns             Rotation matrix.
- */
-export declare function getRotationMatrix(matrix3d: string): number[];
-/**
- * Extracts the translation matrix from the matrix3d CSS string.
- *
- * @param matrix3d      CSS string obtained from
- *                      window
- *                          .getComputedStyle(element)
- *                          .getPropertyValue("transform").
- * @returns             Translation matrix.
- */
-export declare function getTranslationMatrix(matrix3d: string): number[];
-/**
- * Extracts the scalation value from the matrix3d CSS string.
- *
- * @param matrix3d      CSS string obtained from
- *                      window
- *                          .getComputedStyle(element)
- *                          .getPropertyValue("transform").
- * @returns             Scalation value.
- */
-export declare function getScalationValue(matrix3d: string): number;
-/**
- * Returns a a matrix3d CSS string.
- *
- * @param       rotationMatrix
- * @param       translationMatrix
- * @param       scalationMatrix
- * @returns     matrix3d CSS string.
- */
-export declare function setTransform(rotationMatrix: number[], translationMatrix: number[], scalationMatrix: number[]): string;
-interface RotationValues {
-    rotateX: number;
-    rotateY: number;
-    rotateZ: number;
-}
-export declare function getTransformRotate(matrix3d: string): RotationValues;
-interface TranslationValues {
-    translateX: number;
-    translateY: number;
-    translateZ: number;
-}
-export declare function getTransformTranslate(matrix3d: string): TranslationValues;
-interface ScalationValue {
-    scale: number;
-}
-export declare function getTransformScale(matrix3d: string): ScalationValue;
-export declare function rotatePlurid(matrix3d: string, direction?: string, angleIncrement?: number): string;
-export declare function translatePlurid(matrix3d: string, direction?: string, linearIncrement?: number): string;
-export declare function scalePlurid(matrix3d: string, direction?: string, scaleIncrement?: number): string;
-export {};
+import * as general from './general';
+import * as matrix3d from './matrix3d';
+export { general, matrix3d, };

package/distribution/modules/interaction/mathematics/transform/matrix3d/index.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Converts the CSS string matrix3d into an array of numbers.
+ *
+ * @param matrix3d      CSS string obtained from
+ *                      window
+ *                          .getComputedStyle(element)
+ *                          .getPropertyValue('transform').
+ * @returns             Numbers array.
+ */
+export declare function getMatrixValues(matrix3d: string): number[];
+/**
+ * Extracts the rotation matrix from the matrix3d CSS string.
+ *
+ * @param matrix3d      CSS string obtained from
+ *                      window
+ *                          .getComputedStyle(element)
+ *                          .getPropertyValue("transform").
+ * @returns             Rotation matrix.
+ */
+export declare function getRotationMatrix(matrix3d: string): number[];
+/**
+ * Extracts the translation matrix from the matrix3d CSS string.
+ *
+ * @param matrix3d      CSS string obtained from
+ *                      window
+ *                          .getComputedStyle(element)
+ *                          .getPropertyValue("transform").
+ * @returns             Translation matrix.
+ */
+export declare function getTranslationMatrix(matrix3d: string): number[];
+/**
+ * Extracts the scalation value from the matrix3d CSS string.
+ *
+ * @param matrix3d      CSS string obtained from
+ *                      window
+ *                          .getComputedStyle(element)
+ *                          .getPropertyValue("transform").
+ * @returns             Scalation value.
+ */
+export declare function getScalationValue(matrix3d: string): number;
+/**
+ * Returns a a matrix3d CSS string.
+ *
+ * @param       rotationMatrix
+ * @param       translationMatrix
+ * @param       scalationMatrix
+ * @returns     matrix3d CSS string.
+ */
+export declare function setTransform(rotationMatrix: number[], translationMatrix: number[], scalationMatrix: number[]): string;
+interface RotationValues {
+    rotateX: number;
+    rotateY: number;
+    rotateZ: number;
+}
+export declare function getTransformRotate(matrix3d: string): RotationValues;
+interface TranslationValues {
+    translateX: number;
+    translateY: number;
+    translateZ: number;
+}
+export declare function getTransformTranslate(matrix3d: string): TranslationValues;
+interface ScalationValue {
+    scale: number;
+}
+export declare function getTransformScale(matrix3d: string): ScalationValue;
+export declare function rotatePlurid(matrix3d: string, direction?: string, angleIncrement?: number): string;
+export declare function translatePlurid(matrix3d: string, direction?: string, linearIncrement?: number): string;
+export declare function scalePlurid(matrix3d: string, direction?: string, scaleIncrement?: number): string;
+export {};

package/distribution/modules/planes/index.d.ts

@@ -0,0 +1,2 @@
+export * from './logic';
+export * from './registrar';

package/distribution/modules/planes/logic/index.d.ts

@@ -0,0 +1,6 @@
+import { PluridPlane, PluridPlaneObject, PluridRoutePlane, PluridRoutePlaneObject, PluridInternalStatePlane, PluridInternalContextPlane } from '@plurid/plurid-data';
+export declare const resolvePluridPlaneData: <C>(plane: PluridPlane<C>) => PluridPlaneObject<C>;
+export declare const resolvePluridRoutePlaneData: <C>(plane: PluridRoutePlane<C>) => PluridRoutePlaneObject<C>;
+export declare const createInternalStatePlane: <C>(plane: PluridPlane<C>) => PluridInternalStatePlane;
+export declare const createInternalContextPlane: <C>(plane: PluridPlane<C>) => PluridInternalContextPlane<C>;
+export declare const getPluridPlaneIDByData: (element: HTMLElement | null) => string;

package/distribution/modules/planes/registrar/index.d.ts

@@ -0,0 +1,3 @@
+import Registrar from './object';
+export * from './utilities';
+export { Registrar, };

package/distribution/modules/{setup/objects/PlanesRegistrar → planes/registrar}/object.d.ts

@@ -3,11 +3,12 @@ import { PluridPlane, RegisteredPluridPlane, PluridPlanesRegistrar as IPluridPla
  * The planes registrar can be stored in-memory (server-side)
  * or on the `window.__pluridPlanesRegistrar__` object (browser-side).
  */
-declare class PluridPlanesRegistrar implements IPluridPlanesRegistrar {
-    private planes;
-    register(planes: PluridPlane[]): void;
+declare class PluridPlanesRegistrar<C> implements IPluridPlanesRegistrar<C> {
+    private isoMatcher;
+    constructor(planes?: PluridPlane<C>[]);
+    register(planes: PluridPlane<C>[]): void;
     identify(): string[];
-    get(route: string): RegisteredPluridPlane | undefined;
-    getAll(): Map<string, RegisteredPluridPlane>;
+    get(route: string): RegisteredPluridPlane<C> | undefined;
+    getAll(): Map<any, any>;
 }
 export default PluridPlanesRegistrar;

package/distribution/modules/planes/registrar/utilities.d.ts

@@ -0,0 +1,6 @@
+import { PluridPlane, PluridPlanesRegistrar as IPluridPlanesRegistrar } from '@plurid/plurid-data';
+declare const registerPlanes: <C>(planes?: PluridPlane<C>[] | undefined, planesRegistrar?: IPluridPlanesRegistrar<C> | undefined) => void;
+declare const getPlanesRegistrar: <C>(planesRegistrar: IPluridPlanesRegistrar<C> | undefined) => IPluridPlanesRegistrar<C> | undefined;
+declare const getRegisteredPlanes: <C>(planesRegistrar: IPluridPlanesRegistrar<C> | undefined) => Map<any, any>;
+declare const getRegisteredPlane: <C>(route: string, planesRegistrar: IPluridPlanesRegistrar<C> | undefined) => import("@plurid/plurid-data").RegisteredPluridPlane<C> | undefined;
+export { registerPlanes, getPlanesRegistrar, getRegisteredPlanes, getRegisteredPlane, };

package/distribution/modules/routing/IsoMatcher/index.d.ts

@@ -0,0 +1,44 @@
+import { IsoMatcherData, IsoMatcherIndexedPlane, IsoMatcherPlaneResult, IsoMatcherRouteResult } from '@plurid/plurid-data';
+/**
+ * The `IsoMatcher` gathers all the known information about `routes` and `planes`
+ * and matches client-side or server-side, in-browser or in-plurid.
+ */
+declare class IsoMatcher<C> {
+    private origin;
+    private routesIndex;
+    private planesIndex;
+    private routesKeys;
+    private planesKeys;
+    constructor(data: IsoMatcherData<C>, origin?: string);
+    /**
+     * Matches a `path` with a known `route` or `plane`,
+     * based on the strategy imposed by the `context`.
+     *
+     * @param path
+     * @param context
+     */
+    match(path: string, context: 'route'): IsoMatcherRouteResult<C> | undefined;
+    match(path: string): IsoMatcherPlaneResult<C> | undefined;
+    match(path: string, context: 'plane'): IsoMatcherPlaneResult<C> | undefined;
+    /**
+     * Dynammically update the planes and routes indexes.
+     *
+     * @param data
+     */
+    index(data: IsoMatcherData<C>): void;
+    /**
+     * Clear all data.
+     *
+     */
+    clear(): void;
+    getPlanesIndex(): Map<string, IsoMatcherIndexedPlane<C>>;
+    /**
+     * Creates a common data structure able to match and route accordingly.
+     *
+     */
+    private updateIndexes;
+    private indexPlanes;
+    private matchPlane;
+    private matchRoute;
+}
+export default IsoMatcher;

package/distribution/modules/{setup/router → routing}/Parser/index.d.ts

@@ -1,12 +1,12 @@
 import { PluridRoute } from '@plurid/plurid-data';
-import { ParserPartialOptions, ParserResponse } from "./interfaces";
-export default class Parser<T> {
+import { ParserPartialOptions, ParserResponse } from './interfaces';
+export default class Parser<C> {
     /** properties */
     private location;
     private path;
     private options;
     /** constructor */
-    constructor(location: string, path: PluridRoute, options?: ParserPartialOptions);
+    constructor(location: string, path: PluridRoute<C>, options?: ParserPartialOptions);
     /** private */
     private handleOptions;
     private extractPathname;
@@ -17,5 +17,5 @@ export default class Parser<T> {
     /**
      * Extract pathname, parameters, query, and fragment, if available.
      */
-    extract(): ParserResponse;
+    extract(): ParserResponse<C>;
 }

package/distribution/modules/{setup/router → routing}/Parser/interfaces.d.ts

@@ -6,8 +6,8 @@ export interface ParserOptions {
      */
     fragment: boolean;
 }
-export interface ParserResponse {
-    path: PluridRoute;
+export interface ParserResponse<C> {
+    path: PluridRoute<C>;
     pathname: string;
     elements: string[];
     match: boolean;
@@ -16,6 +16,14 @@ export interface ParserResponse {
     fragments: PluridRouteFragments;
     route: string;
 }
+export interface MatcherResponse<C> {
+    path: PluridRoute<C>;
+    pathname: string;
+    parameters: Record<string, string>;
+    query: Record<string, string>;
+    fragments: PluridRouteFragments;
+    route: string;
+}
 export interface ParserParametersAndMatch {
     match: boolean;
     parameters: Indexed<string>;

package/distribution/modules/{setup/router → routing}/Parser/logic.d.ts

@@ -1,5 +1,5 @@
 import { Indexed, PluridRouteFragments, PluridRouteFragmentElement, PluridRouteFragmentText } from '@plurid/plurid-data';
-import { ParserParametersAndMatch } from "./interfaces";
+import { ParserParametersAndMatch } from './interfaces';
 export declare const extractPathname: (location: string) => string;
 /**
  * Extracts the parameters names from a `route`.
@@ -63,6 +63,6 @@ export declare const splitPath: (path: string) => string[];
  * @param path
  */
 export declare const extractQuery: (path: string) => Indexed<string>;
-export declare const extractFragments: (location?: string | undefined) => PluridRouteFragments;
+export declare const extractFragments: (location?: string) => PluridRouteFragments;
 export declare const parseFragment: (fragment: string) => PluridRouteFragmentText | PluridRouteFragmentElement | undefined;
 export declare const extractOccurence: (occurence: string | undefined) => number;

package/distribution/modules/routing/index.d.ts

@@ -0,0 +1,6 @@
+import IsoMatcher from './IsoMatcher';
+import RouteParser from './Parser';
+import { extractQuery } from './Parser/logic';
+export * from './Parser/interfaces';
+export * from './logic';
+export { IsoMatcher, RouteParser, extractQuery, };

package/distribution/modules/routing/logic/general/index.d.ts

@@ -0,0 +1,8 @@
+export declare const stringInsertInitial: (value: string, insert: string) => string;
+export declare const stringRemoveTrailing: (value: string, trail: string) => string;
+export declare const cleanupPath: (value: string) => string;
+export declare const computePlaneAddress: (plane: string, route?: string, origin?: string) => string;
+export declare const isAbsolutePlane: (value: string) => boolean;
+export declare const checkPlaneAddressType: (value: string) => "pttp" | "https" | "http" | "relative";
+export declare const removeTrailingSlash: (value: string) => string;
+export declare const cleanPathValue: (value: string) => string;

package/distribution/modules/routing/logic/index.d.ts

@@ -0,0 +1,3 @@
+export * from './general';
+export * from './validity';
+export * from './utilities';

package/distribution/modules/{setup/router → routing/logic}/utilities/index.d.ts

@@ -1,5 +1,5 @@
 import { Indexed, PluridRoute, RouteDivisions } from '@plurid/plurid-data';
-export declare const mapPathsToRoutes: <T, V>(paths: Indexed<string>, view: V) => PluridRoute[];
+export declare const mapPathsToRoutes: <C, V>(paths: Indexed<string>, view: V) => PluridRoute<C, any>[];
 export declare const pluridLinkPathDivider: (route: string) => RouteDivisions;
 /**
  * Given a partial `route`, e.g. `/route`, or `://cluster://route`,
@@ -8,7 +8,7 @@ export declare const pluridLinkPathDivider: (route: string) => RouteDivisions;
  *
  * @param path
  */
-export declare const resolveRoute: (route: string, protocol?: string | undefined, host?: string | undefined) => {
+export declare const resolveRoute: (route: string, protocol?: string, host?: string) => {
     protocol: string;
     host: import("@plurid/plurid-data").RouteHostDivision;
     path: import("@plurid/plurid-data").RoutePathDivision;
@@ -17,4 +17,13 @@ export declare const resolveRoute: (route: string, protocol?: string | undefined
     cluster: import("@plurid/plurid-data").RouteClusterDivision;
     plane: import("@plurid/plurid-data").RoutePlaneDivision;
     route: string;
+} | {
+    protocol: string;
+    host: string;
+    path: import("@plurid/plurid-data").RoutePathDivision;
+    space: string;
+    universe: string;
+    cluster: string;
+    plane: string;
+    route: string;
 };

package/distribution/modules/routing/logic/validity/index.d.ts

@@ -0,0 +1,3 @@
+import { CompareType, Indexed, PluridRouteParameter } from '@plurid/plurid-data';
+export declare const checkParameterLength: (parameter: string, length: number, compareType?: CompareType) => boolean;
+export declare const checkValidPath: <C>(validationParameters: Record<string, PluridRouteParameter> | undefined, parameters: Indexed<string>) => boolean;

package/distribution/modules/space/index.d.ts

@@ -0,0 +1,6 @@
+import * as layout from './layout';
+import * as location from './location';
+import * as tree from './tree';
+import * as utilities from './utilities';
+import * as view from './view';
+export { layout, location, tree, utilities, view, };

package/distribution/modules/{setup/space → space}/layout/column.d.ts

@@ -1,3 +1,3 @@
 import { PluridConfiguration, TreePlane } from '@plurid/plurid-data';
-declare const computeColumnLayout: (roots: TreePlane[], columns?: number, columnLength?: number | undefined, gap?: number, configuration?: PluridConfiguration) => TreePlane[];
+declare const computeColumnLayout: (roots: TreePlane[], columns?: number, columnLength?: number, gap?: number, configuration?: PluridConfiguration) => TreePlane[];
 export default computeColumnLayout;

package/distribution/modules/space/layout/index.d.ts

@@ -0,0 +1,6 @@
+import computeColumnLayout from './column';
+import computeRowLayout from './row';
+import computeFaceToFaceLayout from './faceToFace';
+import computeSheavesLayout from './sheaves';
+import computeZigZagLayout from './zigZag';
+export { computeColumnLayout, computeRowLayout, computeFaceToFaceLayout, computeSheavesLayout, computeZigZagLayout, };

package/distribution/modules/{setup/space → space}/layout/row.d.ts

@@ -1,3 +1,3 @@
 import { PluridConfiguration, TreePlane } from '@plurid/plurid-data';
-declare const computeRowLayout: (roots: TreePlane[], rows?: number, rowLength?: number | undefined, gap?: number, configuration?: PluridConfiguration) => TreePlane[];
+declare const computeRowLayout: (roots: TreePlane[], rows?: number, rowLength?: number, gap?: number, configuration?: PluridConfiguration) => TreePlane[];
 export default computeRowLayout;

package/distribution/modules/{setup/space → space}/location/index.d.ts

@@ -1,2 +1,2 @@
-import { computePath, computePluridPlaneLocation, recomputeChildrenLocation } from "./logic";
+import { computePath, computePluridPlaneLocation, recomputeChildrenLocation } from './logic';
 export { computePath, computePluridPlaneLocation, recomputeChildrenLocation, };

package/distribution/modules/{setup/space → space}/location/logic.d.ts

@@ -12,7 +12,7 @@ export declare const recomputeChildrenLocation: (page: TreePlane) => TreePlane[]
  * @param root
  * @param index
  */
-export declare const computeRootLocationX: (configuration: PluridConfiguration | undefined, root: PluridPlane, index: number) => number;
+export declare const computeRootLocationX: <C>(configuration: PluridConfiguration | undefined, root: PluridPlane<C>, index: number) => number;
 export declare const computeSpaceLocation: (configuration: PluridConfiguration) => SpaceLocation;
 /**
  * Based on the specified camera, compute the X translation

package/distribution/modules/space/tree/index.d.ts

@@ -0,0 +1,3 @@
+import Tree from './object';
+import * as logic from './logic';
+export { Tree, logic, };

package/distribution/modules/space/tree/logic.d.ts

@@ -0,0 +1,37 @@
+import { 
+/** interfaces */
+PluridView, PluridApplicationView, PluridConfiguration, RegisteredPluridPlane, TreePlane, LinkCoordinates, PathParameters } from '@plurid/plurid-data';
+/**
+ * Given a view resolve it to an absolute view
+ * and compute a TreePlane if there is a RegisteredPluridPlane
+ * for that absolute view.
+ *
+ * @param view
+ */
+export declare const resolveViewItem: <C>(planes: Map<string, RegisteredPluridPlane<C>>, view: string | PluridView, configuration: PluridConfiguration, origin?: string) => TreePlane | undefined;
+/**
+ * Compute the space based on the layout.
+ * If there is no configuration.space.layout, it uses the default '2 COLUMNS' layout.
+ *
+ * @param planes
+ * @param configuration
+ */
+export declare const computeSpaceTree: <C>(planes: Map<string, RegisteredPluridPlane<C>>, view: PluridApplicationView, configuration: PluridConfiguration, origin?: string) => TreePlane[];
+export declare const isParametric: (viewRoute: string, planeRoute: string) => boolean;
+export declare const matchForParameters: (viewRoute: string, planeRoute: string) => void;
+export declare const assignPagesFromView: (planes: TreePlane[], view?: PluridApplicationView) => TreePlane[];
+export declare const updateTreePlane: (tree: TreePlane[], updatedPage: TreePlane) => TreePlane[];
+export interface UpdatedTreeWithNewPlane {
+    pluridPlaneID: string;
+    updatedTree: TreePlane[];
+    updatedTreePlane?: TreePlane;
+}
+export declare const updateTreeWithNewPlane: <C>(planeRoute: string, parentPlaneID: string, linkCoordinates: LinkCoordinates, tree: TreePlane[], planesRegistry: Map<string, RegisteredPluridPlane<C>>, configuration: PluridConfiguration) => UpdatedTreeWithNewPlane;
+export declare const updateTreeWithNewPage: (tree: TreePlane[], treePageParentPlaneID: string, pagePath: string, pageID: string, linkCoordinates: LinkCoordinates, parameters?: PathParameters) => UpdatedTreeWithNewPlane;
+export declare const removePageFromTree: (tree: TreePlane[], pluridPlaneID: string) => TreePlane[];
+export declare const toggleChildren: (children: TreePlane[]) => TreePlane[];
+export interface TogglePlaneFromTree {
+    updatedTree: TreePlane[];
+    updatedPlane: TreePlane | undefined;
+}
+export declare const togglePlaneFromTree: (tree: TreePlane[], pluridPlaneID: string) => TogglePlaneFromTree;

package/distribution/modules/space/tree/object.d.ts

@@ -0,0 +1,14 @@
+import { TreePlane, RegisteredPluridPlane, PluridConfiguration, PluridApplicationView, PluridCluster } from '@plurid/plurid-data';
+export interface TreeData<C> {
+    planes: Map<string, RegisteredPluridPlane<C>>;
+    view: PluridApplicationView;
+    configuration: PluridConfiguration;
+    clusters?: PluridCluster<C>[];
+    previousTree?: TreePlane[];
+}
+export default class Tree<C> {
+    private data;
+    private origin;
+    constructor(data: TreeData<C>, origin?: string);
+    compute(): TreePlane[];
+}

package/distribution/modules/{setup/space → space}/view/index.d.ts

@@ -1,2 +1,2 @@
-import { computeViewTree, computeCulledView, checkPageInView } from "./logic";
+import { computeViewTree, computeCulledView, checkPageInView } from './logic';
 export { computeViewTree, computeCulledView, checkPageInView, };

package/distribution/modules/state/compute/index.d.ts

@@ -0,0 +1,3 @@
+import { PluridApplicationView, PluridConfiguration, PluridPlanesRegistrar as IPluridPlanesRegistrar, PluridState, PluridMetastateState, RecursivePartial } from '@plurid/plurid-data';
+declare const compute: <C>(view: PluridApplicationView, configuration: RecursivePartial<PluridConfiguration> | undefined, planesRegistrar: IPluridPlanesRegistrar<C> | undefined, currentState: PluridState | undefined, localState: PluridState | undefined, precomputedState: Partial<PluridState> | undefined, contextState: PluridMetastateState | undefined) => PluridState;
+export default compute;

package/distribution/modules/state/compute/space/index.d.ts

@@ -0,0 +1,3 @@
+import { PluridApplicationView, PluridConfiguration, PluridPlanesRegistrar as IPluridPlanesRegistrar, PluridState, PluridMetastateState, PluridStateSpace } from '@plurid/plurid-data';
+declare const resolveSpace: <C>(view: PluridApplicationView, configuration: PluridConfiguration, planesRegistrar: IPluridPlanesRegistrar<C> | undefined, currentState: PluridState | undefined, localState: PluridState | undefined, precomputedState: Partial<PluridState> | undefined, contextState: PluridMetastateState | undefined) => PluridStateSpace;
+export { resolveSpace, };

package/distribution/modules/state/index.d.ts

@@ -0,0 +1,3 @@
+import compute from './compute';
+import * as local from './local';
+export { compute, local, };