bruce-models 0.1.6 → 0.1.8

package/dist/types/api/idm-api.d.ts

@@ -1,11 +1,16 @@
 import { AbstractApi } from "./abstract-api";
 import { Api } from "./api";
+/**
+ * This is the request handler for Idm Api,
+ * it should be passed to any method that wants to communicate with this particular api.
+ */
 export declare class IdmApi extends AbstractApi {
     private baseUrl;
     private env;
     constructor(env?: Api.Env);
     private setBaseUrl;
     GetBaseUrl(): string;
+    SetBaseUrl(url: string): void;
     GET(url: string, params?: Api.IReqParams): Promise<any>;
     DELETE(url: string, params?: Api.IReqParams): Promise<any>;
     POST(url: string, data: any, params?: Api.IReqParams): Promise<any>;

package/dist/types/bruce-models.d.ts

@@ -1,4 +1,5 @@
 export * from "./ann-document/ann-document";
+export * from "./custom-form/custom-form";
 export * from "./api/abstract-api";
 export * from "./api/api";
 export * from "./api/bruce-api";
@@ -54,6 +55,7 @@ export * from "./user/permission";
 export * from "./user/session";
 export * from "./user/user-group";
 export * from "./user/user";
+export * from "./account/account";
 export * from "./util/encrypt-utils";
 export * from "./util/math-utils";
 export * from "./util/object-utils";

package/dist/types/calculator/calculator.d.ts

@@ -1,5 +1,9 @@
 import { Color } from "../common/color";
 import { Entity } from "../entity/entity";
+/**
+ * Utility for calculating values from Bruce fields.
+ * These fields are typically found in entity styles.
+ */
 export declare namespace Calculator {
     enum EValueType {
         Color = 0,
@@ -31,6 +35,14 @@ export declare namespace Calculator {
         value: IGradientValue | IMappingValue | string | number;
         type: EValueType;
     }
+    /**
+     * Calculates the value of arbitrary field options.
+     * The context calling this should validate results and parse stuff if needed.
+     * @param fields
+     * @param entity
+     * @param tags
+     * @returns
+     */
     function GetValue(fields: IField[], entity: Entity.IEntity, tags: any[]): string | number | Color.IColor;
     function GetMappingValue(value: IMappingValue, entity: Entity.IEntity): string | number;
     function GetGradientValue(value: IGradientValue, entity: Entity.IEntity): Color.IColor;

package/dist/types/common/bounds.d.ts

@@ -1,4 +1,7 @@
 export declare namespace Bounds {
+    /**
+     * Description of an entity's bounding box.
+     */
     interface IBounds {
         maxLatitude: number;
         maxLongitude: number;
@@ -7,6 +10,9 @@ export declare namespace Bounds {
         maxAltitude: number;
         minAltitude: number;
     }
+    /**
+     * Describes the boundaries used in entity requests.
+     */
     interface IReqBounds {
         south: number;
         west: number;

package/dist/types/common/bruce-event.d.ts

@@ -1,3 +1,7 @@
+/**
+ * Simple event utility.
+ * Instantiate the model, then subscribe and trigger events.
+ */
 export declare class BruceEvent<TArgs> {
     private _counter;
     private callbacks;

package/dist/types/common/bruce-variable.d.ts

@@ -1,4 +1,17 @@
 import { Entity } from "../entity/entity";
+/**
+ * Utilities for parsing "Bruce variables", typically within strings.
+ *
+ * A Bruce variable is a string that starts with "${" and ends with "}".
+ * Within those brackets is a path to an attribute in an entity.
+ */
 export declare namespace BruceVariable {
+    /**
+     * Replaces all Bruce variables in a string with the value of the attribute.
+     * @param str
+     * @param data
+     * @param legacyParse
+     * @returns
+     */
     function SwapValues(str: string, data: Entity.IEntity, legacyParse?: boolean): string;
 }

package/dist/types/common/cache.d.ts

@@ -1,4 +1,7 @@
 declare type Key = string | number;
+/**
+ * Simple local cache controller.
+ */
 export declare class CacheControl<T> {
     private data;
     Disabled: boolean;

package/dist/types/common/cartes.d.ts

@@ -1,3 +1,9 @@
+/**
+ * Describes 2d and 3d coordinates.
+ *
+ * In 2d the x/y typically refers to a window left/top offset.
+ * In 3d the x/y/z, the units are in meters.
+ */
 export declare namespace Cartes {
     interface ICartes2 {
         x: number;

package/dist/types/common/carto.d.ts

@@ -1,3 +1,8 @@
+/**
+ * Describes a geographic point.
+ * The units of the stored data should be in Degrees.
+ * Utilities may use this in Radians for temporary calculations.
+ */
 export declare namespace Carto {
     interface ICarto {
         latitude: number;

package/dist/types/common/color.d.ts

@@ -15,5 +15,10 @@ export declare namespace Color {
         blendPercent?: number;
     }
     function RandomColor(): IColor;
+    /**
+     * Attempts to parse a given color string into a model.
+     * @param str
+     * @returns
+     */
     function ColorFromStr(str: string): IColor;
 }

package/dist/types/common/delay-queue.d.ts

@@ -1,3 +1,7 @@
+/**
+ * Controls the flow of method calls.
+ * If you have a method that may be called often, but you don't want it to run often, use this.
+ */
 export declare class DelayQueue {
     private callback;
     delay: number;

package/dist/types/common/geometry.d.ts

@@ -1,4 +1,7 @@
 import { Carto } from "./carto";
+/**
+ * Describes vector geometry that Bruce uses.
+ */
 export declare namespace Geometry {
     interface IGeometry {
         Polygon?: IPolygonRing[];
@@ -16,8 +19,26 @@ export declare namespace Geometry {
         Boundaries = "out",
         Hole = "in"
     }
+    /**
+     * Turns an array of points into string vector geometry that Bruce can use.
+     * This is used for saving polyline and polygon data.
+     * @param points
+     * @returns
+     */
     function LineStrFromPoints(points: Carto.ICarto[]): string;
+    /**
+     * Removes same points that occur in a row.
+     * This will not modify the original array.
+     * @param positions
+     * @returns
+     */
     function RemoveRepeatPoints(positions: Carto.ICarto[]): Carto.ICarto[];
     function ParsePoints(data: string): Carto.ICarto[];
+    /**
+     * Parses both string and object Bruce geometry.
+     * String geometry is legacy Bruce data.
+     * @param geometry
+     * @returns
+     */
     function ParseGeometry(geometry: any): IGeometry;
 }

package/dist/types/common/transform.d.ts

@@ -1,4 +1,8 @@
 export declare namespace Transform {
+    /**
+     * Stored in degrees typically.
+     * Will be stored in radians when in bookmarks/project-views annoyingly.
+     */
     interface ITransform {
         heading: number;
         pitch: number;

package/dist/types/common/utc.d.ts

@@ -1,3 +1,6 @@
+/**
+ * Describes a Bruce stored date.
+ */
 export declare namespace UTC {
     enum EMonth {
         January = 1,

package/dist/types/custom-form/custom-form.d.ts

@@ -0,0 +1,25 @@
+import { BruceApi } from "../api/bruce-api";
+import { Markup } from "../markup/markup";
+/**
+ * Describes the "Custom Form" concept within Bruce.
+ * Custom forms are dynamic dialogs that get populated with Entity data.
+ */
+export declare namespace CustomForm {
+    function GetCacheKey(id: number): string;
+    function GetListCacheKey(typeId: string): string;
+    interface IForm {
+        ID?: number;
+        "EntityType.ID"?: string;
+        Name?: string;
+        Settings?: any | Markup.IMarkup;
+        Type?: EType;
+    }
+    enum EType {
+        Form = "GENERIC",
+        Markup = "MARKUP"
+    }
+    function Get(api: BruceApi, id: number): Promise<IForm>;
+    function Delete(api: BruceApi, id: number): Promise<void>;
+    function GetList(api: BruceApi, typeId: string): Promise<IForm[]>;
+    function Update(api: BruceApi, data: IForm): Promise<IForm>;
+}

package/dist/types/entity/entity-attachment-type.d.ts

@@ -1,5 +1,9 @@
 import { BruceApi } from "../api/bruce-api";
 declare type Type = EntityAttachmentType.EType | string;
+/**
+ * Describes the "Entity Attachment Type" concept within Bruce.
+ * It is a record that describes the purpose of an attachment.
+ */
 export declare namespace EntityAttachmentType {
     function GetCacheKey(id: Type): string;
     function GetListCacheKey(): string;
@@ -10,10 +14,7 @@ export declare namespace EntityAttachmentType {
     }
     enum EType {
         Photo = "photo",
-        Document = "document",
-        Video = "video",
-        Drawing = "drawing",
-        Model = "model"
+        Document = "document"
     }
     function Delete(api: BruceApi, id: Type): Promise<void>;
     function Update(api: BruceApi, data: IType): Promise<IType>;

package/dist/types/entity/entity-attachment.d.ts

@@ -2,6 +2,11 @@ import { BruceApi } from "../bruce-models";
 import { ClientFile } from "../file/client-file";
 import { EntityAttachmentType } from "./entity-attachment-type";
 declare type Type = EntityAttachmentType.EType | string;
+/**
+ * Describes the "Entity Attachment" concept within Bruce.
+ * An entity attachment is an arbitrary file record that is linked to an entity record.
+ * The same file can be attached to multiple entities.
+ */
 export declare namespace EntityAttachment {
     function GetCacheKey(entityId: string, typeId: Type, fileId: string): string;
     function GetListCacheKey(entityId: string): string;

package/dist/types/entity/entity-comment.d.ts

@@ -1,4 +1,8 @@
 import { BruceApi, UTC } from "../bruce-models";
+/**
+ * Describes the "Entity Comment" concept within Bruce.
+ * An entity comment is a user written message that is linked to an entity record.
+ */
 export declare namespace EntityComment {
     function GetCacheKey(id: number): string;
     function GetListCacheKey(entityId: string): string;

package/dist/types/entity/entity-link.d.ts

@@ -1,4 +1,8 @@
 import { BruceApi } from "../bruce-models";
+/**
+ * Describes the "Entity Link" concept within Bruce.
+ * An entity link is a URL linked to an entity record.
+ */
 export declare namespace EntityLink {
     function GetCacheKey(id: number): string;
     function GetListCacheKey(entityId: string): string;

package/dist/types/entity/entity-lod.d.ts

@@ -1,4 +1,10 @@
 import { BruceApi } from "../bruce-models";
+/**
+ * Describes the "Entity LOD" concept within Bruce.
+ * LOD stands for Level of Detail.
+ * An lod record is a possible 2d/3d visualization of the entity record.
+ * The most common kind is a GLB.
+ */
 export declare namespace EntityLod {
     function GetCacheKey(url: string): string;
     interface ILod {

package/dist/types/entity/entity-relation-type.d.ts

@@ -1,4 +1,8 @@
 import { BruceApi } from "../api/bruce-api";
+/**
+ * Describes the "Entity Relationship Type" concept within Bruce.
+ * A relationship type record describes the purpose of a relationship.
+ */
 export declare namespace EntityRelationType {
     function GetCacheKey(id: string): string;
     function GetListCacheKey(): string;

package/dist/types/entity/entity-relation.d.ts

@@ -1,5 +1,10 @@
 import { BruceApi } from "../api/bruce-api";
 import { Entity } from "./entity";
+/**
+ * Describes the "Entity Relationship" concept within Bruce.
+ * An entity relationship is an arbitrary link between two entity records.
+ * The relationship can have a "data entity" linked to it as well for the relationship to store arbitrary data about itself.
+ */
 export declare namespace EntityRelation {
     function GetCacheKey(entityA: string, entityB: string, typeId: string): string;
     function GetEntityCacheKey(entityId: string): string;

package/dist/types/entity/entity-source.d.ts

@@ -1,4 +1,9 @@
 import { BruceApi, IDictionary } from "../bruce-models";
+/**
+ * Describes the "Entity Source" concept within Bruce.
+ * An entity source is a record which links an arbitrary source id to a Bruce entity id.
+ * For example an OSM building id to a Bruce entity id.
+ */
 export declare namespace EntitySource {
     function GetCacheKey(sourceId: number, sourceKey: string): string;
     interface ISource {

package/dist/types/entity/entity-tag.d.ts

@@ -1,4 +1,9 @@
 import { BruceApi } from "../api/bruce-api";
+/**
+ * Describes the "Entity Tag" concept within Bruce.
+ * An entity tag is used to categorize an entity record.
+ * Entity tags can be used in filters, or to restrict entity access.
+ */
 export declare namespace EntityTag {
     function GetCacheKey(tagId: number): string;
     function GetListCacheKey(entityTypeId?: string): string;

package/dist/types/entity/entity-type.d.ts

@@ -1,5 +1,10 @@
 import { BruceApi } from "../api/bruce-api";
 import { UTC } from "../bruce-models";
+/**
+ * Describes the "Entity Type" concept within Bruce.
+ * An entity type is an "expectation" of what data "should" look like in a particular entity record.
+ * The schema is stencils onto entity data to filter out what we should display or search against.
+ */
 export declare namespace EntityType {
     function GetCacheKey(typeId: string): string;
     function GetListCacheKey(): string;

package/dist/types/entity/entity.d.ts

@@ -8,6 +8,11 @@ import { UTC } from "../common/utc";
 import { EntityType } from "./entity-type";
 import { IDictionary } from "../common/dictionary";
 declare type _any = any;
+/**
+ * Describes the "Entity" concept within Bruce.
+ * An entity is a JSON blob containing both internal data and user-defined data.
+ * Entity records have many thinks linked to them through their UIDs such as links, files and relationships.
+ */
 export declare namespace Entity {
     function GetCacheKey(entityId: string): string;
     interface IEntity extends _any {

package/dist/types/entity/getters/batched-data-getter.d.ts

@@ -1,5 +1,9 @@
 import { BruceEvent } from "../../common/bruce-event";
 import { ViewMonitor } from "./view-monitor";
+/**
+ * This is a batched "arbitrary data" getter.
+ * You feed it an array of data, then it will emit that data in batches when the view changes.
+ */
 export declare namespace BatchedDataGetter {
     class Getter<T> {
         private viewPort;

package/dist/types/entity/getters/entity-filter-getter.d.ts

@@ -3,6 +3,11 @@ import { BruceEvent } from "../../common/bruce-event";
 import { IDictionary } from "../../common/dictionary";
 import { Entity } from "../entity";
 import { ViewMonitor } from "./view-monitor";
+/**
+ * This is a batched entity getter.
+ * It will scan for entity records in a view-area and emit them in batches.
+ * It will restart scanning if the camera moves.
+ */
 export declare namespace EntityFilterGetter {
     enum EStatus {
         Scanning = "SCANNING",

package/dist/types/entity/getters/entity-globe.d.ts

@@ -6,6 +6,11 @@ declare class Cell {
     Boundaries: Bounds.IBounds;
     GetBounds(): Bounds.IReqBounds;
 }
+/**
+ * This is a helper for making entity requests based on a grid area.
+ * It will return grid cells based on given view-area then will remember when stuff-
+ * was fully-fetched for those cells to avoid making duplicate requests.
+ */
 export declare namespace EntityGlobe {
     class Grid {
         private cells;

package/dist/types/file/client-file.d.ts

@@ -1,5 +1,9 @@
 import { BruceApi } from "../bruce-models";
 import { UTC } from "../common/utc";
+/**
+ * Describes the "Client File" concept within Bruce.
+ * A client file is a record of a file uploaded to Bruce.
+ */
 export declare namespace ClientFile {
     function GetCacheKey(fileId: string): string;
     interface IClientFile {

package/dist/types/markup/markup.d.ts

@@ -1,4 +1,7 @@
 import { Cartes, EntityAttachmentType } from "../bruce-models";
+/**
+ * Description of a "Markup" which is stored in custom-form or bookmark records.
+ */
 export declare namespace Markup {
     interface IMarkup {
         divs?: Element.Div.IDiv[];

package/dist/types/program-key/program-key.d.ts

@@ -1,5 +1,9 @@
 import { BruceApi } from "../api/bruce-api";
 declare type Id = ProgramKey.EProgramId | string;
+/**
+ * Describes the "Program Key" concept within Bruce.
+ * A program key is an access token for an arbitrary software.
+ */
 export declare namespace ProgramKey {
     function GetCacheKey(programId: string): string;
     function GetListCacheKey(): string;

package/dist/types/project/menu-item.d.ts

@@ -1,6 +1,11 @@
 import { Entity } from "../entity/entity";
 import { Tileset } from "../tileset/tileset";
 import { ZoomControl } from "./zoom-control";
+/**
+ * Describes a menu item found in project views.
+ * Menu items are used to dictate what data to load in a scene.
+ * A menu item may be a container for other items.
+ */
 export declare namespace MenuItem {
     enum EType {
         None = "NONE",

package/dist/types/project/project-view-bookmark.d.ts

@@ -2,6 +2,12 @@ import { BruceApi } from "../api/bruce-api";
 import { Camera } from "../common/camera";
 import { UTC } from "../common/utc";
 import { Markup } from "../markup/markup";
+/**
+ * Describe the "Project View Bookmark" concept within Bruce.
+ * This is referred to as "slides" in older code.
+ *
+ * A bookmark is a snapshot of what should be displayed and how in a particular project view.
+ */
 export declare namespace ProjectViewBookmark {
     function GetCacheKey(viewId: string, bookmarkId: string): string;
     function GetListCacheKey(): string;

package/dist/types/project/project-view-tile-source.d.ts

@@ -1,3 +1,8 @@
+/**
+ * Describes a terrain or map source that are found in project view records.
+ * This is a concept we want to trash as we're moving towards storing tileset ids instead.
+ * This will help at least understand and manage this dying concept.
+ */
 export declare namespace ProjectViewTileSource {
     interface ISource {
         IsEnabled?: boolean;

package/dist/types/project/project-view.d.ts

@@ -2,6 +2,11 @@ import { BruceApi } from "../api/bruce-api";
 import { UTC } from "../common/utc";
 import { MenuItem } from "./menu-item";
 import { ProjectViewTileSource } from "./project-view-tile-source";
+/**
+ * Describes the "Project View" concept within Bruce.
+ * A project view is a collection of settings for a visualization application we support.
+ * It will describe what panels to show and how, it will also describe all possible ways data can be displayed.
+ */
 export declare namespace ProjectView {
     function GetCacheKey(viewId: string): string;
     function GetListCacheKey(): string;

package/dist/types/project/zoom-control.d.ts

@@ -1,4 +1,8 @@
 import { Style } from "../bruce-models";
+/**
+ * Describes an expectation on what should be rendered for a menu item-
+ * between a min-max distance of an entity to the camera.
+ */
 export declare namespace ZoomControl {
     enum EDisplayType {
         Hidden = "hidden",

package/dist/types/server/pending-action.d.ts

@@ -1,5 +1,10 @@
 import { Api } from "../api/api";
 import { BruceApi, UTC } from "../bruce-models";
+/**
+ * Describes the "Pending Action" concept within Bruce.
+ * A pending action is a record of a server-side background process.
+ * This record is used to monitor its progress and completion state.
+ */
 export declare namespace PendingAction {
     interface IAction {
         ID: number;

package/dist/types/style/style.d.ts

@@ -1,4 +1,11 @@
 import { BruceApi, Calculator } from "../bruce-models";
+/**
+ * Describes the "Style" concept within Bruce.
+ * A legacy way of referring to styles is "entity display settings".
+ *
+ * A style is a collection of settings (which can be calculations to perform on entity data) that
+ * describe how an entity should be displayed.
+ */
 export declare namespace Style {
     function GetCacheKey(id: number): string;
     function GetListCacheKey(): string;

package/dist/types/tileset/tileset-cad.d.ts

@@ -1,5 +1,9 @@
 import { Tileset } from "../bruce-models";
 import { Carto } from "../common/carto";
+/**
+ * Describes expected settings for a CAD tileset.
+ * A CAD tileset is sometimes referred to as a "MODEL" tileset in Bruce.
+ */
 export declare namespace TilesetCad {
     interface ISettings {
         rootEntityId: string;

package/dist/types/tileset/tileset-entities-map-tiles.d.ts

@@ -1,4 +1,9 @@
 import { Bounds } from "../common/bounds";
+/**
+ * Describes expected settings for an entities-map tileset.
+ * This is the kind of tileset generated from arbitrary Bruce entities-
+ * which produced map tiles of the entity vector geometry.
+ */
 export declare namespace TilesetEntitiesMapTiles {
     enum ETileSize {
         IMG_256 = 256,

package/dist/types/tileset/tileset-entities.d.ts

@@ -1,4 +1,8 @@
 import { Bounds } from "../bruce-models";
+/**
+ * Describes expected settings for an entities-set tileset.
+ * This is the kind of tileset generated from arbitrary Bruce entities.
+ */
 export declare namespace TilesetEntities {
     interface ISettings {
         zoomControl?: any[];

package/dist/types/tileset/tileset-ext-map-tiles.d.ts

@@ -1,3 +1,7 @@
+/**
+ * Describes settings for an external map-tiles tileset.
+ * This will serve content from elsewhere with the assumption that the data is valid map tiles.
+ */
 export declare namespace TilesetExtMapTiles {
     enum EType {
         TileMapImagery = "TileMapImagery",

package/dist/types/tileset/tileset-ext-terrain-tiles.d.ts

@@ -1,3 +1,7 @@
+/**
+ * Describes settings for an external terrain-tiles tileset.
+ * This will serve content from elsewhere with the assumption that the data is valid terrain tiles.
+ */
 export declare namespace TilesetExtTerrainTiles {
     interface ISettings {
         requestVertexNormals?: boolean;

package/dist/types/tileset/tileset-map-tiles.d.ts

@@ -1,3 +1,7 @@
+/**
+ * Describes settings for a map-tiles tileset.
+ * This tileset will ingest a .tif file and produce pictures to serve as map tiles.
+ */
 export declare namespace TilesetMapTiles {
     interface ISettings {
         sourceFileId: string;

package/dist/types/tileset/tileset-pointcloud.d.ts

@@ -1,5 +1,9 @@
 import { Tileset } from "../bruce-models";
 import { Carto } from "../common/carto";
+/**
+ * Describes settings for a point-cloud tileset.
+ * This tileset ingests a .laz or .las file and produces a point cloud that can be streamed into viewers.
+ */
 export declare namespace TilesetPointcloud {
     interface ISettings {
         sourceFileIds: string[];

package/dist/types/tileset/tileset-terrain-tiles.d.ts

@@ -1,3 +1,7 @@
+/**
+ * Describes settings for a terrain-tiles tileset.
+ * This tileset will ingest a .tif file and produce pictures to serve as terrain tiles.
+ */
 export declare namespace TilesetTerrainTiles {
     interface ISettings {
         sourceFileId?: string;

package/dist/types/tileset/tileset.d.ts

@@ -10,6 +10,16 @@ import { TilesetMapTiles } from "./tileset-map-tiles";
 import { TilesetTerrainTiles } from "./tileset-terrain-tiles";
 import { GlobalApi } from "../api/global-api";
 declare type Settings = TilesetPointcloud.ISettings | TilesetCad.ISettings | TilesetEntitiesMapTiles.ISettings | TilesetEntities.ISettings | TilesetExtMapTiles.ISettings | TilesetExtTerrainTiles.ISettings | TilesetMapTiles.ISettings | TilesetTerrainTiles.ISettings;
+/**
+ * Describes the "Tileset" concept in Bruce.
+ *
+ * Tilesets come in three possible variants,
+ * 1- A set of instructions to generate a tileset.
+ * 2- Settings to load a tileset hosted elsewhere.
+ * 3- A set of user-provided files to serve.
+ *
+ * Read the individual tileset-type settings for each variant.
+ */
 export declare namespace Tileset {
     function GetCacheKey(tilesetId: string, loadFiles: boolean): string;
     function GetListCacheKey(): string;

package/dist/types/ucs/ucs.d.ts

@@ -1,4 +1,9 @@
 import { BruceApi, Tileset } from "../bruce-models";
+/**
+ * Describes the "UCS" concept within Bruce.
+ * A UCS is a user-coordinate-system.
+ * It is a description of an offset to apply to tilesets so that they can all align with each other.
+ */
 export declare namespace Ucs {
     function GetCacheKey(id: number, expandUsage: boolean): string;
     function GetListCacheKey(): string;

package/dist/types/user/session.d.ts

@@ -2,6 +2,11 @@ import { IdmApi } from "../api/idm-api";
 import { UTC } from "../common/utc";
 import { Permission } from "./permission";
 import { User } from "./user";
+/**
+ * Describes the "Session" concept within Bruce.
+ * A session is a set of settings produced from a user or access token login.
+ * The session describes what the access should be allowed to do.
+ */
 export declare namespace Session {
     interface ISession {
         AccessPermissions: IAccessPermissions;