lucid-extension-sdk 0.0.165 → 0.0.166

package/commandtypes.d.ts

@@ -36,11 +36,13 @@ export declare const enum CommandName {
     CreateBlock = "cb",
     CreateCollection = "cc",
     CreateDataSource = "cds",
+    CreateDocumentElement = "cde",
     CreateLine = "cl",
     CreatePage = "cp",
     CreateUserImage = "cui",
     DataAction = "da",
     DataItemExists = "die",
+    DeleteDocumentElement = "dde",
     DeleteItem = "di",
     DeletePage = "dp",
     DeleteShapeData = "dsd",
@@ -198,6 +200,10 @@ export declare type CommandArgs = {
         query: CreateDataSourceQuery;
         result: CreateDataSourceResult;
     };
+    [CommandName.CreateDocumentElement]: {
+        query: CreateDocumentElementQuery;
+        result: CreateDocumentElementResult;
+    };
     [CommandName.CreateLine]: {
         query: CreateLineQuery;
         result: CreateLineResult;
@@ -218,6 +224,10 @@ export declare type CommandArgs = {
         query: DataItemExistsQuery;
         result: DataItemExistsResult;
     };
+    [CommandName.DeleteDocumentElement]: {
+        query: DeleteDocumentElementQuery;
+        result: DeleteDocumentElementResult;
+    };
     [CommandName.DeleteItem]: {
         query: DeleteItemQuery;
         result: DeleteItemResult;
@@ -768,6 +778,13 @@ export declare type CreateDataSourceQuery = {
     };
 };
 export declare type CreateDataSourceResult = string;
+export declare type CreateDocumentElementQuery = {
+    /** Type of element to create */
+    't': DocumentElementType;
+    /** Properties to set on that element */
+    'p': Record<string, any>;
+};
+export declare type CreateDocumentElementResult = string | undefined;
 export declare type CreateLineQuery = {
     /**
      * By default, we add the line to the current page & currently active group. If specified, the
@@ -819,6 +836,8 @@ export declare type DataItemExistsQuery = {
     'pk': string;
 };
 export declare type DataItemExistsResult = boolean;
+export declare type DeleteDocumentElementQuery = string;
+export declare type DeleteDocumentElementResult = boolean;
 export declare type DeleteItemQuery = string;
 export declare type DeleteItemResult = boolean;
 export declare type DeletePageQuery = string;

package/commandtypes.js

@@ -20,9 +20,11 @@ exports.commandTitles = new Map([
     ["cb" /* CommandName.CreateBlock */, 'CreateBlock'],
     ["cc" /* CommandName.CreateCollection */, 'CreateCollection'],
     ["cds" /* CommandName.CreateDataSource */, 'CreateDataSource'],
+    ["cde" /* CommandName.CreateDocumentElement */, 'CreateDocumentElement'],
     ["cl" /* CommandName.CreateLine */, 'CreateLine'],
     ["cp" /* CommandName.CreatePage */, 'CreatePage'],
     ["die" /* CommandName.DataItemExists */, 'DataItemExists'],
+    ["dde" /* CommandName.DeleteDocumentElement */, 'DeleteDocumentElement'],
     ["di" /* CommandName.DeleteItem */, 'DeleteItem'],
     ["dp" /* CommandName.DeletePage */, 'DeletePage'],
     ["dsd" /* CommandName.DeleteShapeData */, 'DeleteShapeData'],

package/core/properties/strokestyle.d.ts

@@ -0,0 +1,22 @@
+export declare enum StrokeStyle {
+    Solid = "solid",
+    Dashed = "dashed",
+    LongDash = "longdash",
+    DashDot = "dashdot",
+    DashDotDot = "dashdotdot",
+    DashLongDash = "dashlongdash",
+    Dashed32 = "dashed32",
+    Dashed44 = "dashed44",
+    Dashed24 = "dashed24",
+    Dotted = "dotted",
+    DotDotDot = "dotdotdot",
+    StripeThinThin = "stripethinthin",
+    StripeThickThick = "stripethickthick",
+    StripeThickThin = "stripethickthin",
+    StripeThinThick = "stripethinthick",
+    StripeThickThinThick = "stripethickthinthick",
+    StripeThinThickThin = "stripethinthickthin",
+    StripeTriple = "stripetriple"
+}
+export declare function isStrokeStyle(value: any): value is StrokeStyle;
+export declare function convertStrokeStyleToBorder(strokeStyle: StrokeStyle): string;

package/core/properties/strokestyle.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertStrokeStyleToBorder = exports.isStrokeStyle = exports.StrokeStyle = void 0;
+var StrokeStyle;
+(function (StrokeStyle) {
+    StrokeStyle["Solid"] = "solid";
+    StrokeStyle["Dashed"] = "dashed";
+    StrokeStyle["LongDash"] = "longdash";
+    StrokeStyle["DashDot"] = "dashdot";
+    StrokeStyle["DashDotDot"] = "dashdotdot";
+    StrokeStyle["DashLongDash"] = "dashlongdash";
+    StrokeStyle["Dashed32"] = "dashed32";
+    StrokeStyle["Dashed44"] = "dashed44";
+    StrokeStyle["Dashed24"] = "dashed24";
+    StrokeStyle["Dotted"] = "dotted";
+    StrokeStyle["DotDotDot"] = "dotdotdot";
+    StrokeStyle["StripeThinThin"] = "stripethinthin";
+    StrokeStyle["StripeThickThick"] = "stripethickthick";
+    StrokeStyle["StripeThickThin"] = "stripethickthin";
+    StrokeStyle["StripeThinThick"] = "stripethinthick";
+    StrokeStyle["StripeThickThinThick"] = "stripethickthinthick";
+    StrokeStyle["StripeThinThickThin"] = "stripethinthickthin";
+    StrokeStyle["StripeTriple"] = "stripetriple";
+})(StrokeStyle = exports.StrokeStyle || (exports.StrokeStyle = {}));
+const strokeStyleSet = new Set(Object.values(StrokeStyle));
+function isStrokeStyle(value) {
+    return strokeStyleSet.has(value);
+}
+exports.isStrokeStyle = isStrokeStyle;
+function convertStrokeStyleToBorder(strokeStyle) {
+    if (strokeStyle.startsWith('dash') || strokeStyle == StrokeStyle.LongDash) {
+        return 'dashed';
+    }
+    else if (strokeStyle.startsWith('dot')) {
+        return 'dotted';
+    }
+    else {
+        return 'solid';
+    }
+}
+exports.convertStrokeStyleToBorder = convertStrokeStyleToBorder;

package/core/rules/badgeboxfit.d.ts

@@ -0,0 +1,4 @@
+export declare enum BadgeBoxFit {
+    fitHeight = "fit-height",
+    none = "none"
+}

package/core/rules/badgeboxfit.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BadgeBoxFit = void 0;
+var BadgeBoxFit;
+(function (BadgeBoxFit) {
+    BadgeBoxFit["fitHeight"] = "fit-height";
+    BadgeBoxFit["none"] = "none";
+})(BadgeBoxFit = exports.BadgeBoxFit || (exports.BadgeBoxFit = {}));

package/core/rules/conditions.d.ts

@@ -0,0 +1,43 @@
+export declare enum ConditionCombination {
+    AND = "AND",
+    OR = "OR"
+}
+export declare enum TextConditions {
+    TextEmpty = 0,
+    TextNotEmpty = 1,
+    TextContains = 2,
+    TextDoesNotContain = 3
+}
+export declare enum ShapeDataConditions {
+    TextEmpty = 0,
+    TextNotEmpty = 1,
+    TextContains = 2,
+    TextDoesNotContain = 3,
+    /** @deprecated */ TextEquals = 4,
+    /** @deprecated */ TextNotEqual = 5,
+    TextStartsWith = 6,
+    TextEndsWith = 7,
+    GreaterThan = 8,
+    GreaterThanOrEqual = 9,
+    LessThan = 10,
+    LessThanOrEqual = 11,
+    Equal = 12,
+    NotEqual = 13,
+    Between = 14,
+    NotBetween = 15
+}
+export declare enum ShapeTypeConditions {
+    TextContains = 2,
+    TextDoesNotContain = 3
+}
+export declare enum ConnectedShapesCondition {
+    GreaterThan = 8,
+    GreaterThanOrEqual = 9,
+    LessThan = 10,
+    LessThanOrEqual = 11,
+    Equal = 12,
+    NotEqual = 13,
+    Between = 14,
+    NotBetween = 15
+}
+export declare type Conditions = TextConditions | ShapeDataConditions | ShapeTypeConditions | ConnectedShapesCondition;

package/core/rules/conditions.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConnectedShapesCondition = exports.ShapeTypeConditions = exports.ShapeDataConditions = exports.TextConditions = exports.ConditionCombination = void 0;
+var ConditionCombination;
+(function (ConditionCombination) {
+    ConditionCombination["AND"] = "AND";
+    ConditionCombination["OR"] = "OR";
+})(ConditionCombination = exports.ConditionCombination || (exports.ConditionCombination = {}));
+var TextConditions;
+(function (TextConditions) {
+    TextConditions[TextConditions["TextEmpty"] = 0] = "TextEmpty";
+    TextConditions[TextConditions["TextNotEmpty"] = 1] = "TextNotEmpty";
+    TextConditions[TextConditions["TextContains"] = 2] = "TextContains";
+    TextConditions[TextConditions["TextDoesNotContain"] = 3] = "TextDoesNotContain";
+})(TextConditions = exports.TextConditions || (exports.TextConditions = {}));
+var ShapeDataConditions;
+(function (ShapeDataConditions) {
+    ShapeDataConditions[ShapeDataConditions["TextEmpty"] = 0] = "TextEmpty";
+    ShapeDataConditions[ShapeDataConditions["TextNotEmpty"] = 1] = "TextNotEmpty";
+    ShapeDataConditions[ShapeDataConditions["TextContains"] = 2] = "TextContains";
+    ShapeDataConditions[ShapeDataConditions["TextDoesNotContain"] = 3] = "TextDoesNotContain";
+    /** @deprecated */ ShapeDataConditions[ShapeDataConditions["TextEquals"] = 4] = "TextEquals";
+    /** @deprecated */ ShapeDataConditions[ShapeDataConditions["TextNotEqual"] = 5] = "TextNotEqual";
+    ShapeDataConditions[ShapeDataConditions["TextStartsWith"] = 6] = "TextStartsWith";
+    ShapeDataConditions[ShapeDataConditions["TextEndsWith"] = 7] = "TextEndsWith";
+    ShapeDataConditions[ShapeDataConditions["GreaterThan"] = 8] = "GreaterThan";
+    ShapeDataConditions[ShapeDataConditions["GreaterThanOrEqual"] = 9] = "GreaterThanOrEqual";
+    ShapeDataConditions[ShapeDataConditions["LessThan"] = 10] = "LessThan";
+    ShapeDataConditions[ShapeDataConditions["LessThanOrEqual"] = 11] = "LessThanOrEqual";
+    ShapeDataConditions[ShapeDataConditions["Equal"] = 12] = "Equal";
+    ShapeDataConditions[ShapeDataConditions["NotEqual"] = 13] = "NotEqual";
+    ShapeDataConditions[ShapeDataConditions["Between"] = 14] = "Between";
+    ShapeDataConditions[ShapeDataConditions["NotBetween"] = 15] = "NotBetween";
+})(ShapeDataConditions = exports.ShapeDataConditions || (exports.ShapeDataConditions = {}));
+var ShapeTypeConditions;
+(function (ShapeTypeConditions) {
+    ShapeTypeConditions[ShapeTypeConditions["TextContains"] = 2] = "TextContains";
+    ShapeTypeConditions[ShapeTypeConditions["TextDoesNotContain"] = 3] = "TextDoesNotContain";
+})(ShapeTypeConditions = exports.ShapeTypeConditions || (exports.ShapeTypeConditions = {}));
+var ConnectedShapesCondition;
+(function (ConnectedShapesCondition) {
+    ConnectedShapesCondition[ConnectedShapesCondition["GreaterThan"] = 8] = "GreaterThan";
+    ConnectedShapesCondition[ConnectedShapesCondition["GreaterThanOrEqual"] = 9] = "GreaterThanOrEqual";
+    ConnectedShapesCondition[ConnectedShapesCondition["LessThan"] = 10] = "LessThan";
+    ConnectedShapesCondition[ConnectedShapesCondition["LessThanOrEqual"] = 11] = "LessThanOrEqual";
+    ConnectedShapesCondition[ConnectedShapesCondition["Equal"] = 12] = "Equal";
+    ConnectedShapesCondition[ConnectedShapesCondition["NotEqual"] = 13] = "NotEqual";
+    ConnectedShapesCondition[ConnectedShapesCondition["Between"] = 14] = "Between";
+    ConnectedShapesCondition[ConnectedShapesCondition["NotBetween"] = 15] = "NotBetween";
+})(ConnectedShapesCondition = exports.ConnectedShapesCondition || (exports.ConnectedShapesCondition = {}));

package/core/rules/conditiontype.d.ts

@@ -0,0 +1,7 @@
+export declare enum ConditionType {
+    Text = 0,
+    ShapeData = 1,
+    Formula = 2,
+    ShapeType = 3,
+    ConnectedShapes = 4
+}

package/core/rules/conditiontype.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConditionType = void 0;
+var ConditionType;
+(function (ConditionType) {
+    ConditionType[ConditionType["Text"] = 0] = "Text";
+    ConditionType[ConditionType["ShapeData"] = 1] = "ShapeData";
+    ConditionType[ConditionType["Formula"] = 2] = "Formula";
+    ConditionType[ConditionType["ShapeType"] = 3] = "ShapeType";
+    ConditionType[ConditionType["ConnectedShapes"] = 4] = "ConnectedShapes";
+})(ConditionType = exports.ConditionType || (exports.ConditionType = {}));

package/core/rules/serializedcondition.d.ts

@@ -0,0 +1,16 @@
+import { Conditions } from './conditions';
+import { ConditionType } from './conditiontype';
+export declare type Between = {
+    'After': number | undefined;
+    'Before': number | undefined;
+};
+export declare type ConditionValueType = string | number | boolean | Between | undefined | Array<string>;
+/** See lucid-extension-sdk/document/documentelement/ruleproxy.ts for a description of each of these fields */
+export declare type SerializedCondition = {
+    'Type': ConditionType;
+    'Source': string;
+    'Condition': Conditions;
+    'Value'?: ConditionValueType;
+    'Label'?: string | undefined;
+    'DisplayLabel'?: string | undefined;
+};

package/core/rules/serializedcondition.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/core/rules/serializeddatagraphic.d.ts

@@ -0,0 +1,14 @@
+import { SerializedBadgeEnumPosition } from '../properties/datagraphic/badgeposition';
+import { DataGraphicIconSets } from '../properties/datagraphic/datagraphicindexes';
+export declare type SerializedDataGraphic = {
+    'Set': DataGraphicIconSets;
+    'Index': number;
+    'Position': SerializedBadgeEnumPosition;
+    'Color'?: string;
+    'Image'?: SerializedDataGraphicImage;
+};
+export declare type SerializedDataGraphicImage = {
+    'url': string;
+    'w': number;
+    'h': number;
+};

package/core/rules/serializeddatagraphic.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/core/rules/serializedeffect.d.ts

@@ -0,0 +1,25 @@
+import { ConditionCombination } from './conditions';
+import { SerializedDataGraphic } from './serializeddatagraphic';
+import { SerializedStencilGraphic } from './serializedstencilgraphic';
+export declare type FormattingInterface = {
+    [index: string]: string;
+};
+export declare type SerializedFormatting = {
+    'Block'?: FormattingInterface;
+    'Line'?: FormattingInterface;
+    'Page'?: FormattingInterface;
+};
+export declare enum RuleFormattingType {
+    FORMATTING = 0,
+    DATA_GRAPHICS = 1,
+    STENCIL = 2
+}
+export declare type SerializedEffect = {
+    'ConditionOrder': number[];
+    'Combination': ConditionCombination;
+    'FormatType': RuleFormattingType;
+    'Formatting': SerializedFormatting;
+    'DataGraphic'?: SerializedDataGraphic | undefined;
+    'StencilGraphic'?: SerializedStencilGraphic | undefined;
+    'Tooltip'?: string | undefined;
+};

package/core/rules/serializedeffect.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RuleFormattingType = void 0;
+var RuleFormattingType;
+(function (RuleFormattingType) {
+    RuleFormattingType[RuleFormattingType["FORMATTING"] = 0] = "FORMATTING";
+    RuleFormattingType[RuleFormattingType["DATA_GRAPHICS"] = 1] = "DATA_GRAPHICS";
+    RuleFormattingType[RuleFormattingType["STENCIL"] = 2] = "STENCIL";
+})(RuleFormattingType = exports.RuleFormattingType || (exports.RuleFormattingType = {}));

package/core/rules/serializedstencilgraphic.d.ts

@@ -0,0 +1,16 @@
+import { SerializedBadgeEnumPosition } from '../properties/datagraphic/badgeposition';
+import { BadgeBoxFit } from './badgeboxfit';
+export declare type SerializedStencilGraphic = {
+    'Stencil': string;
+    'Properties': {
+        [index: string]: number | string | boolean;
+    };
+    /**
+     * AutoHide used to be an undefined property that should default to true.
+     * Either continue handling undefined case when deserializing, or write a BCU that changes undefined to true.
+     */
+    'AutoHide'?: boolean;
+    'Badge'?: SerializedBadgeEnumPosition;
+    'BoxFit'?: BadgeBoxFit;
+};
+export declare const isSerializedStencilGraphic: (v: unknown) => v is SerializedStencilGraphic;

package/core/rules/serializedstencilgraphic.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isSerializedStencilGraphic = void 0;
+const checks_1 = require("../checks");
+const badgeposition_1 = require("../properties/datagraphic/badgeposition");
+const validators_1 = require("../validators/validators");
+const badgeboxfit_1 = require("./badgeboxfit");
+exports.isSerializedStencilGraphic = (0, validators_1.objectValidator)({
+    'Stencil': checks_1.isString,
+    'Properties': (0, validators_1.objectOfValidator)((0, validators_1.either)(checks_1.isBoolean, (0, validators_1.either)(checks_1.isString, checks_1.isNumber))),
+    'AutoHide': (0, validators_1.option)(checks_1.isBoolean),
+    'Badge': (0, validators_1.option)(badgeposition_1.isValidSerializedBadgeEnumPosition),
+    'BoxFit': (0, validators_1.option)((0, validators_1.enumValidator)(badgeboxfit_1.BadgeBoxFit)),
+});

package/document/documentelement/ruleproxy.d.ts

@@ -0,0 +1,81 @@
+import { EditorClient } from '../../editorclient';
+import { MapProxy } from '../mapproxy';
+import { ConditionDefinition, EffectDefinition } from '../ruledefinition';
+import { DocumentElementProxy } from './documentelementproxy';
+export declare class RuleCondition {
+    readonly rule: RuleProxy;
+    private readonly client;
+    readonly key: string;
+    private definition;
+    constructor(rule: RuleProxy, client: EditorClient, key: string);
+    /** What kind of condition is this? e.g. a formula evaluation, checking for non-empty text, etc. */
+    readonly type: import("../..").ConditionType;
+    /**
+     * If this.type == ConditionType.Text, this is a TextConditions.
+     * If this.type == ConditionType.ShapeData, this is a ShapeDataConditions.
+     * If this.type == ConditionType.ShapeType, this is a ShapeTypeConditions.
+     * If this.type == ConditionType.ConnectedShapes, this is a ConnectedShapesConditions.
+     */
+    readonly condition: import("../..").Conditions;
+    /**
+     * For formula conditions, the formula string.
+     *
+     * For other conditions,the value against which the condition is tested. For example, a condition with
+     *  type = ConditionType.ShapeData
+     *  condition = ShapeDataConditions.GreaterThan
+     *  field = 'TheField'
+     *  value = 14
+     *
+     * will trigger when the shape data field "TheField" has a value that is greater than 14.
+     */
+    readonly value: import("../../core/rules/serializedcondition").ConditionValueType;
+    /** For shape data conditions, the name of the shape data field to test */
+    readonly field: string | undefined;
+    /** For shape data conditions, the name to display to the end user to identify the field name */
+    readonly fieldLabel: string | undefined;
+    /** Update this condition to reflect a new definition */
+    update(definition: ConditionDefinition): void;
+}
+export declare class RuleEffect {
+    readonly rule: RuleProxy;
+    private readonly client;
+    readonly key: string;
+    private definition;
+    constructor(rule: RuleProxy, client: EditorClient, key: string);
+    readonly conditions: MapProxy<string, RuleCondition>;
+    /** How multiple conditions are combined (AND vs OR) */
+    readonly combination: import("../..").ConditionCombination;
+    /** What kind of effect is displayed? Formatting vs. icons vs. dynamic stencil, etc. */
+    readonly formatType: import("../../core/rules/serializedeffect").RuleFormattingType;
+    /** For formatType = RuleFormattingType.FORMATTING, what styles are applied to blocks, lines, and pages? */
+    readonly formatting: import("../../core/rules/serializedeffect").SerializedFormatting;
+    /** For formatType = RuleFormattingType.DATA_GRAPHICS, a description of which icon appears and where */
+    readonly dataGraphic: {
+        set: import("../..").DataGraphicIconSets;
+        index: number;
+        position: import("../../core/properties/datagraphic/badgeposition").BadgeEnumPosition;
+        color: string | undefined;
+        image: {
+            url: string;
+            w: number;
+            h: number;
+        } | undefined;
+    } | undefined;
+    /** Update this effect to reflect a new definition */
+    update(definition: EffectDefinition): void;
+}
+export declare class RuleProxy extends DocumentElementProxy {
+    readonly id: string;
+    /**
+     * @param id The ID of this conditional formatting rule
+     * @param client
+     */
+    constructor(id: string, client: EditorClient);
+    getName(): string;
+    getOrder(): number;
+    readonly effects: MapProxy<string, RuleEffect>;
+    /**
+     * Delete this conditional formatting rule from the document
+     */
+    delete(): void;
+}

package/document/documentelement/ruleproxy.js

@@ -0,0 +1,118 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RuleProxy = exports.RuleEffect = exports.RuleCondition = void 0;
+const badgeposition_1 = require("../../core/properties/datagraphic/badgeposition");
+const mapproxy_1 = require("../mapproxy");
+const ruledefinition_1 = require("../ruledefinition");
+const documentelementproxy_1 = require("./documentelementproxy");
+class RuleCondition {
+    constructor(rule, client, key) {
+        this.rule = rule;
+        this.client = client;
+        this.key = key;
+        this.definition = this.rule.properties.get(this.key);
+        /** What kind of condition is this? e.g. a formula evaluation, checking for non-empty text, etc. */
+        this.type = this.definition['Type'];
+        /**
+         * If this.type == ConditionType.Text, this is a TextConditions.
+         * If this.type == ConditionType.ShapeData, this is a ShapeDataConditions.
+         * If this.type == ConditionType.ShapeType, this is a ShapeTypeConditions.
+         * If this.type == ConditionType.ConnectedShapes, this is a ConnectedShapesConditions.
+         */
+        this.condition = this.definition['Condition'];
+        /**
+         * For formula conditions, the formula string.
+         *
+         * For other conditions,the value against which the condition is tested. For example, a condition with
+         *  type = ConditionType.ShapeData
+         *  condition = ShapeDataConditions.GreaterThan
+         *  field = 'TheField'
+         *  value = 14
+         *
+         * will trigger when the shape data field "TheField" has a value that is greater than 14.
+         */
+        this.value = this.definition['Value'];
+        /** For shape data conditions, the name of the shape data field to test */
+        this.field = this.definition['Label'];
+        /** For shape data conditions, the name to display to the end user to identify the field name */
+        this.fieldLabel = this.definition['DisplayLabel'];
+    }
+    /** Update this condition to reflect a new definition */
+    update(definition) {
+        this.rule.properties.set(this.key, (0, ruledefinition_1.serializeConditionDefinition)(definition));
+        this.definition = this.rule.properties.get(this.key);
+    }
+}
+exports.RuleCondition = RuleCondition;
+class RuleEffect {
+    constructor(rule, client, key) {
+        this.rule = rule;
+        this.client = client;
+        this.key = key;
+        this.definition = this.rule.properties.get(this.key);
+        this.conditions = new mapproxy_1.MapProxy(() => this.definition['ConditionOrder'].map((order) => 'Condition_' + order), (key) => new RuleCondition(this.rule, this.client, key));
+        /** How multiple conditions are combined (AND vs OR) */
+        this.combination = this.definition['Combination'];
+        /** What kind of effect is displayed? Formatting vs. icons vs. dynamic stencil, etc. */
+        this.formatType = this.definition['FormatType'];
+        /** For formatType = RuleFormattingType.FORMATTING, what styles are applied to blocks, lines, and pages? */
+        this.formatting = this.definition['Formatting'];
+        /** For formatType = RuleFormattingType.DATA_GRAPHICS, a description of which icon appears and where */
+        this.dataGraphic = this.definition['DataGraphic'] && {
+            set: this.definition['DataGraphic']['Set'],
+            index: this.definition['DataGraphic']['Index'],
+            position: (0, badgeposition_1.deserializeBadgeEnumPosition)(this.definition['DataGraphic']['Position']),
+            color: this.definition['DataGraphic']['Color'],
+            image: this.definition['DataGraphic']['Image'] && {
+                url: this.definition['DataGraphic']['Image']['url'],
+                w: this.definition['DataGraphic']['Image']['w'],
+                h: this.definition['DataGraphic']['Image']['h'],
+            },
+        };
+    }
+    /** Update this effect to reflect a new definition */
+    update(definition) {
+        //Find the maximum used condition index in the entire rule, in case we need to add more.
+        let nextConditionIndex = 1;
+        for (const effect of this.rule.effects.values()) {
+            nextConditionIndex = Math.max(nextConditionIndex, ...effect.definition.ConditionOrder.map((index) => index + 1));
+        }
+        const conditionIndexes = this.definition.ConditionOrder;
+        definition.conditions.forEach((condition, index) => {
+            let conditionIndex = conditionIndexes[index];
+            if (conditionIndex === undefined) {
+                //Added a new condition
+                conditionIndex = nextConditionIndex;
+                conditionIndexes.push(nextConditionIndex++);
+            }
+            const conditionKey = 'Condition_' + conditionIndex;
+            this.rule.properties.set(conditionKey, (0, ruledefinition_1.serializeConditionDefinition)(condition));
+        });
+        this.rule.properties.set(this.key, (0, ruledefinition_1.serializeEffectDefinition)(definition, conditionIndexes.slice(0, definition.conditions.length)));
+    }
+}
+exports.RuleEffect = RuleEffect;
+class RuleProxy extends documentelementproxy_1.DocumentElementProxy {
+    /**
+     * @param id The ID of this conditional formatting rule
+     * @param client
+     */
+    constructor(id, client) {
+        super(id, client);
+        this.id = id;
+        this.effects = new mapproxy_1.MapProxy(() => this.properties.get('EffectOrder').map((order) => 'Effect_' + order), (key) => new RuleEffect(this, this.client, key));
+    }
+    getName() {
+        return this.properties.get('Name');
+    }
+    getOrder() {
+        return this.properties.get('Order');
+    }
+    /**
+     * Delete this conditional formatting rule from the document
+     */
+    delete() {
+        this.client.sendCommand("dde" /* CommandName.DeleteDocumentElement */, this.id);
+    }
+}
+exports.RuleProxy = RuleProxy;

package/document/documentproxy.d.ts

@@ -1,10 +1,12 @@
 import { EditorClient } from '../editorclient';
 import { CardConfigProxy } from './documentelement/cardconfigproxy';
+import { RuleProxy } from './documentelement/ruleproxy';
 import { ElementProxy } from './elementproxy';
 import { ItemProxy } from './itemproxy';
 import { MapProxy } from './mapproxy';
 import { PageDefinition } from './pagedefinition';
 import { PageProxy } from './pageproxy';
+import { RuleDefinition } from './ruledefinition';
 /**
  * The currently-open Lucid document
  */
@@ -68,6 +70,8 @@ export declare class DocumentProxy extends ElementProxy {
      */
     unhookCreateItems(handle: string): void;
     readonly cardIntegrationConfigs: MapProxy<string, CardConfigProxy>;
+    readonly rules: MapProxy<string, RuleProxy>;
+    addRule(definition: RuleDefinition): RuleProxy | undefined;
     /**
      * Watch for new blocks, lines, or groups deleted from this document. The callback will
      * be called with items deleted by the current user, but will not be called with items

package/document/documentproxy.js

@@ -3,9 +3,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.DocumentProxy = void 0;
 const cardconfigproxy_1 = require("./documentelement/cardconfigproxy");
 const documentelementtype_1 = require("./documentelement/documentelementtype");
+const ruleproxy_1 = require("./documentelement/ruleproxy");
 const elementproxy_1 = require("./elementproxy");
 const mapproxy_1 = require("./mapproxy");
 const pageproxy_1 = require("./pageproxy");
+const ruledefinition_1 = require("./ruledefinition");
 /**
  * The currently-open Lucid document
  */
@@ -17,6 +19,10 @@ class DocumentProxy extends elementproxy_1.ElementProxy {
          */
         this.pages = new mapproxy_1.MapProxy(() => this.client.sendCommand("lp" /* CommandName.ListPages */, undefined), (pageId) => new pageproxy_1.PageProxy(pageId, this.client));
         this.cardIntegrationConfigs = new mapproxy_1.MapProxy(() => this.client.sendCommand("lde" /* CommandName.ListDocumentElements */, { 't': documentelementtype_1.DocumentElementType.TaskCardFieldsConfig }), (id) => new cardconfigproxy_1.CardConfigProxy(id, this.client));
+        this.rules = new mapproxy_1.MapProxy(() => this.client
+            .sendCommand("lde" /* CommandName.ListDocumentElements */, { 't': documentelementtype_1.DocumentElementType.Rule })
+            //Filter down to only the rules with source User (i.e. ones visible in the UI, not ones created internally by the app)
+            .filter((id) => this.client.sendCommand("gp" /* CommandName.GetProperty */, { 'id': id, 'p': 'SourceType' }) === 0), (id) => new ruleproxy_1.RuleProxy(id, this.client));
     }
     static getNextHookName() {
         return '__documentproxy__hook' + DocumentProxy.nextHookId++;
@@ -107,6 +113,38 @@ class DocumentProxy extends elementproxy_1.ElementProxy {
         this.client.deleteAction(handle);
         this.client.sendCommand("uci" /* CommandName.UnhookCreateItems */, { 'n': handle });
     }
+    addRule(definition) {
+        let maxOrder = 0;
+        for (const rule of this.rules.values()) {
+            maxOrder = Math.max(maxOrder, rule.getOrder());
+        }
+        const properties = {
+            'EffectOrder': definition.effects.map((effect, index) => index + 1),
+            'SourceType': 0,
+            'Name': definition.name,
+            'Order': maxOrder + 1,
+        };
+        let nextConditionIndex = 1;
+        let nextEffectIndex = 1;
+        for (const effect of definition.effects) {
+            const effectKey = 'Effect_' + nextEffectIndex++;
+            const conditionOrder = [];
+            for (const condition of effect.conditions) {
+                conditionOrder.push(nextConditionIndex);
+                const conditionKey = 'Condition_' + nextConditionIndex++;
+                properties[conditionKey] = (0, ruledefinition_1.serializeConditionDefinition)(condition);
+            }
+            properties[effectKey] = (0, ruledefinition_1.serializeEffectDefinition)(effect, conditionOrder);
+        }
+        const id = this.client.sendCommand("cde" /* CommandName.CreateDocumentElement */, {
+            't': documentelementtype_1.DocumentElementType.Rule,
+            'p': properties,
+        });
+        if (id === undefined) {
+            return undefined;
+        }
+        return new ruleproxy_1.RuleProxy(id, this.client);
+    }
     /**
      * Watch for new blocks, lines, or groups deleted from this document. The callback will
      * be called with items deleted by the current user, but will not be called with items

package/document/pageproxy.d.ts

@@ -3,6 +3,7 @@ import { EditorClient } from '../editorclient';
 import { Box } from '../math';
 import { BlockDefinition } from './blockdefinition';
 import { BlockProxy } from './blockproxy';
+import { RuleProxy } from './documentelement/ruleproxy';
 import { ElementProxy } from './elementproxy';
 import { GroupProxy } from './groupproxy';
 import { LineDefinition } from './linedefinition';
@@ -18,6 +19,18 @@ export declare class PageProxy extends ElementProxy {
      * @param client
      */
     constructor(id: string, client: EditorClient);
+    /**
+     * @returns All conditional formatting rules that are applied to every item on this page
+     */
+    getRulesAppliedToAllItems(): RuleProxy[];
+    /**
+     * @param rule Rule to apply to all items on this page
+     */
+    applyRuleToAllItems(rule: RuleProxy): void;
+    /**
+     * @param rule Rule to remove from the list applied to all items on this page
+     */
+    unapplyRuleToAllItems(rule: RuleProxy): void;
     /**
      * The blocks contained directly on this page, not including ones inside groups
      */

package/document/pageproxy.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PageProxy = void 0;
+const ruleproxy_1 = require("./documentelement/ruleproxy");
 const elementproxy_1 = require("./elementproxy");
 const groupproxy_1 = require("./groupproxy");
 const lineproxy_1 = require("./lineproxy");
@@ -41,6 +42,32 @@ class PageProxy extends elementproxy_1.ElementProxy {
          */
         this.allGroups = new mapproxy_1.MapProxy(() => this.client.sendCommand("lg" /* CommandName.ListGroups */, { id: this.id, d: true }), (id) => new groupproxy_1.GroupProxy(id, this.client));
     }
+    /**
+     * @returns All conditional formatting rules that are applied to every item on this page
+     */
+    getRulesAppliedToAllItems() {
+        const ids = this.properties.get('ChildRuleList');
+        return ids.map((id) => new ruleproxy_1.RuleProxy(id, this.client));
+    }
+    /**
+     * @param rule Rule to apply to all items on this page
+     */
+    applyRuleToAllItems(rule) {
+        const ids = this.properties.get('ChildRuleList');
+        if (!ids.includes(rule.id)) {
+            ids.push(rule.id);
+            this.properties.set('ChildRuleList', ids);
+        }
+    }
+    /**
+     * @param rule Rule to remove from the list applied to all items on this page
+     */
+    unapplyRuleToAllItems(rule) {
+        const ids = this.properties.get('ChildRuleList');
+        if (ids.includes(rule.id)) {
+            this.properties.set('ChildRuleList', ids.filter((id) => id !== rule.id));
+        }
+    }
     /**
      * Add a new block to this page.
      *

package/document/ruledefinition.d.ts

@@ -0,0 +1,109 @@
+import { BadgeEnumPosition } from '../core/properties/datagraphic/badgeposition';
+import { DataGraphicIconSets } from '../core/properties/datagraphic/datagraphicindexes';
+import { StrokeStyle } from '../core/properties/strokestyle';
+import { ConditionCombination, ShapeDataConditions, TextConditions } from '../core/rules/conditions';
+import { ConditionType } from '../core/rules/conditiontype';
+import { ConditionValueType, SerializedCondition } from '../core/rules/serializedcondition';
+import { RuleFormattingType, SerializedEffect } from '../core/rules/serializedeffect';
+export interface BaseConditionDefinition {
+    /** What kind of condition is this? e.g. a formula evaluation, checking for non-empty text, etc. */
+    type: ConditionType;
+}
+export interface FormulaConditionDefinition extends BaseConditionDefinition {
+    type: ConditionType.Formula;
+    /** The formula string */
+    formula: string;
+}
+export interface ShapeDataConditionDefinition extends BaseConditionDefinition {
+    type: ConditionType.ShapeData;
+    condition: ShapeDataConditions;
+    /**
+     * The value against which the condition is tested. For example, a condition with
+     *  type = ConditionType.ShapeData
+     *  condition = ShapeDataConditions.GreaterThan
+     *  field = 'TheField'
+     *  value = 14
+     *
+     * will trigger when the shape data field "TheField" has a value that is greater than 14.
+     */
+    value?: ConditionValueType;
+    /** The name of the shape data field to test */
+    field: string | undefined;
+    /** The name to display to the end user to identify the field name */
+    fieldLabel?: string | undefined;
+}
+export interface TextConditionDefinition extends BaseConditionDefinition {
+    type: ConditionType.Text;
+    condition: TextConditions;
+    /**
+     * The value against which the condition is tested. For example, a condition with
+     *  type = ConditionType.ShapeData
+     *  condition = ShapeDataConditions.GreaterThan
+     *  field = 'TheField'
+     *  value = 14
+     *
+     * will trigger when the shape data field "TheField" has a value that is greater than 14.
+     */
+    value?: ConditionValueType;
+}
+export declare type ConditionDefinition = FormulaConditionDefinition | ShapeDataConditionDefinition | TextConditionDefinition;
+export interface BaseEffectDefinition {
+    conditions: ConditionDefinition[];
+    /** How multiple conditions are combined (AND vs OR) */
+    combination: ConditionCombination;
+    tooltip?: string | undefined;
+}
+export interface FormattingEffectDefinition extends BaseEffectDefinition {
+    formatType: RuleFormattingType.FORMATTING;
+    formatting: {
+        /** If specified, the color to use for affected block fills */
+        fillColor?: string;
+        /** If specified, the color to use for affected block borders */
+        borderColor?: string;
+        /** If specified, the width to use for affected block borders */
+        borderWidth?: number;
+        /** If specified, the style to use for affected block borders */
+        borderStyle?: StrokeStyle;
+        /** If specified, the color to use for affected lines */
+        lineColor?: string;
+        /** If specified, the width to use for affected lines */
+        lineWidth?: number;
+        /** If specified, the style to use for affected lines */
+        lineStyle?: StrokeStyle;
+    };
+}
+export interface DataGraphicEffectDefinition extends BaseEffectDefinition {
+    formatType: RuleFormattingType.DATA_GRAPHICS;
+    dataGraphic: {
+        set: Exclude<DataGraphicIconSets, DataGraphicIconSets.CUSTOM_ICONS>;
+        index: number;
+        position: BadgeEnumPosition;
+        color?: string;
+    };
+}
+export interface CustomIconEffectDefinition extends BaseEffectDefinition {
+    formatType: RuleFormattingType.DATA_GRAPHICS;
+    dataGraphic: {
+        set: DataGraphicIconSets.CUSTOM_ICONS;
+        position: BadgeEnumPosition;
+        image: {
+            url: string;
+            width: number;
+            height: number;
+        };
+    };
+}
+export declare type EffectDefinition = FormattingEffectDefinition | DataGraphicEffectDefinition | CustomIconEffectDefinition;
+export interface RuleDefinition {
+    /** User-readable name of this conditional formatting rule */
+    name: string;
+    /**
+     * The possible visual effects of this conditional formatting rule,
+     * in priority order. The first effect whose conditions are met is used.
+     */
+    effects: EffectDefinition[];
+}
+/** @ignore */
+export declare function serializeConditionDefinition(condition: ConditionDefinition): SerializedCondition;
+/** @ignore */
+export declare function serializeEffectDefinition(effect: EffectDefinition, conditionOrder: number[]): SerializedEffect;

package/document/ruledefinition.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serializeEffectDefinition = exports.serializeConditionDefinition = void 0;
+const badgeposition_1 = require("../core/properties/datagraphic/badgeposition");
+const datagraphicindexes_1 = require("../core/properties/datagraphic/datagraphicindexes");
+const conditiontype_1 = require("../core/rules/conditiontype");
+const serializedeffect_1 = require("../core/rules/serializedeffect");
+/** @ignore */
+function serializeConditionDefinition(condition) {
+    return Object.assign({ 'Type': condition.type, 'Source': 'this', 'Condition': 0 }, (condition.type === conditiontype_1.ConditionType.Formula
+        ? {
+            'Value': condition.formula,
+        }
+        : condition.type === conditiontype_1.ConditionType.Text
+            ? {
+                'Condition': condition.condition,
+                'Value': condition.value,
+            }
+            : condition.type === conditiontype_1.ConditionType.ShapeData
+                ? {
+                    'Condition': condition.condition,
+                    'Value': condition.value,
+                    'Label': condition.field,
+                    'DisplayLabel': condition.fieldLabel,
+                }
+                : {}));
+}
+exports.serializeConditionDefinition = serializeConditionDefinition;
+/** @ignore */
+function serializeEffectDefinition(effect, conditionOrder) {
+    var _a;
+    return {
+        'ConditionOrder': conditionOrder,
+        'Combination': effect.combination,
+        'FormatType': effect.formatType,
+        'Formatting': effect.formatType === serializedeffect_1.RuleFormattingType.FORMATTING
+            ? {
+                'Block': {
+                    'FillColor': JSON.stringify(effect.formatting.fillColor),
+                    'LineColor': JSON.stringify(effect.formatting.borderColor),
+                    'LineWidth': JSON.stringify(effect.formatting.borderWidth),
+                    'StrokeStyle': JSON.stringify(effect.formatting.borderStyle),
+                },
+                'Line': {
+                    'LineColor': JSON.stringify(effect.formatting.lineColor),
+                    'LineWidth': JSON.stringify(effect.formatting.lineWidth),
+                    'StrokeStyle': JSON.stringify(effect.formatting.lineStyle),
+                },
+            }
+            : {},
+        'DataGraphic': effect.formatType === serializedeffect_1.RuleFormattingType.DATA_GRAPHICS
+            ? effect.dataGraphic.set === datagraphicindexes_1.DataGraphicIconSets.CUSTOM_ICONS
+                ? {
+                    'Set': effect.dataGraphic.set,
+                    'Index': 0,
+                    'Position': (0, badgeposition_1.serializeBadgeEnumPosition)(effect.dataGraphic.position),
+                    'Image': {
+                        'url': effect.dataGraphic.image.url,
+                        'w': effect.dataGraphic.image.width,
+                        'h': effect.dataGraphic.image.height,
+                    },
+                }
+                : {
+                    'Set': effect.dataGraphic.set,
+                    'Index': (_a = effect.dataGraphic.index) !== null && _a !== void 0 ? _a : 0,
+                    'Position': (0, badgeposition_1.serializeBadgeEnumPosition)(effect.dataGraphic.position),
+                    'Color': effect.dataGraphic.color,
+                }
+            : undefined,
+        'Tooltip': effect.tooltip,
+    };
+}
+exports.serializeEffectDefinition = serializeEffectDefinition;

package/index.d.ts

@@ -42,6 +42,10 @@ export * from './core/properties/datagraphic/datagraphicindexes';
 export * from './core/properties/datagraphic/staticdatagraphicsettings';
 export * from './core/properties/fillcolor';
 export * from './core/properties/shadow';
+export * from './core/properties/strokestyle';
+export * from './core/rules/conditions';
+export * from './core/rules/conditiontype';
+export * from './core/rules/serializedeffect';
 export * from './core/serializeddataerror';
 export * from './core/shapedatainheritance';
 export * from './core/spreadsheetintegration/lucidspreadsheetintegration';

package/index.js

@@ -58,6 +58,10 @@ __exportStar(require("./core/properties/datagraphic/datagraphicindexes"), export
 __exportStar(require("./core/properties/datagraphic/staticdatagraphicsettings"), exports);
 __exportStar(require("./core/properties/fillcolor"), exports);
 __exportStar(require("./core/properties/shadow"), exports);
+__exportStar(require("./core/properties/strokestyle"), exports);
+__exportStar(require("./core/rules/conditions"), exports);
+__exportStar(require("./core/rules/conditiontype"), exports);
+__exportStar(require("./core/rules/serializedeffect"), exports);
 __exportStar(require("./core/serializeddataerror"), exports);
 __exportStar(require("./core/shapedatainheritance"), exports);
 __exportStar(require("./core/spreadsheetintegration/lucidspreadsheetintegration"), exports);

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "lucid-extension-sdk",
-    "version": "0.0.165",
+    "version": "0.0.166",
     "description": "Utility classes for writing Lucid Software editor extensions",
     "main": "index.js",
     "types": "index.d.ts",