@atlassian/forge-conditions 0.3.3-next.0

package/CHANGELOG.md

@@ -0,0 +1,120 @@
+# @atlassian/forge-conditions
+
+## 0.3.3-next.0
+
+### Patch Changes
+
+- 9da1330: Add publishConfig
+
+## 0.3.2
+
+### Patch Changes
+
+- a5e7647: Update license for Forge public packages
+
+## 0.3.2-next.0
+
+### Patch Changes
+
+- a5e7647: Update license for Forge public packages
+
+## 0.3.1
+
+### Patch Changes
+
+- 652e9f2: Bump Typescript and ESlint to latest
+
+## 0.3.1-next.0
+
+### Patch Changes
+
+- 652e9f23: Bump Typescript and ESlint to latest
+
+## 0.3.0
+
+### Minor Changes
+
+- 3367e8d: Update display conditions processing logic to support Confluence entity property conditions
+
+### Patch Changes
+
+- 3f30fe8: Export types.ts as part of the library
+
+## 0.3.0-next.1
+
+### Patch Changes
+
+- 3f30fe8: Export types.ts as part of the library
+
+## 0.3.0-next.0
+
+### Minor Changes
+
+- 3367e8d: Update display conditions processing logic to support Confluence entity property conditions
+
+## 0.2.0
+
+### Minor Changes
+
+- a55d9c8: Changed validation and runtime error messages for display conditions
+
+## 0.2.0-next.0
+
+### Minor Changes
+
+- a55d9c8: Changed validation and runtime error messages for display conditions
+
+## 0.1.0
+
+### Minor Changes
+
+- dd27c38: Add display condition types and validation
+
+### Patch Changes
+
+- b41cc4c: Fix exported content
+- 41dcd69: Moved CSP logic to its own package and bridge script to cli-shared
+
+## 0.1.0-next.2
+
+### Patch Changes
+
+- 41dcd69: Moved CSP logic to its own package and bridge script to cli-shared
+
+## 0.1.0-next.1
+
+### Minor Changes
+
+- dd27c38: Add display condition types and validation
+
+## 0.0.5-next.0
+
+### Patch Changes
+
+- b41cc4c: Fix exported content
+
+## 0.0.4
+
+### Patch Changes
+
+- 059a822: Set build target to ES5
+
+## 0.0.4-next.0
+
+### Patch Changes
+
+- 059a822: Set build target to ES5
+
+## 0.0.3
+
+## 0.0.2
+
+### Patch Changes
+
+- 1546f65: Add an initial version of Forge conditions
+
+## 0.0.2-next.0
+
+### Patch Changes
+
+- 1546f65: Add an initial version of Forge conditions

package/LICENSE.txt

@@ -0,0 +1,7 @@
+Copyright (c) 2025 Atlassian
+Permission is hereby granted to use this software in accordance with the terms 
+and conditions outlined in the Atlassian Developer Terms, which can be found 
+at the following URL:
+https://developer.atlassian.com/platform/marketplace/atlassian-developer-terms/
+By using this software, you agree to comply with these terms and conditions. 
+If you do not agree with these terms, you are not permitted to use this software.

package/README.md

@@ -0,0 +1,63 @@
+# Forge conditions
+
+The package validates provided conditions against provided data.
+It compares the static data and supports few basic logical operations such as:
+* and
+* or
+* not
+
+## How to use
+
+Import `doesMeetConditions` and invoke it with two arguments to get a `boolean` result:
+```javascript
+doesMeetConditions({}, {}) // true
+doesMeetConditions({}, { isAdmin: false }) // true, no conditions
+doesMeetConditions({ isAdmin: true }, { isAdmin: false }) // false, condition requires an admin
+```
+
+Where the first argument defines what conditions have to be met, and the second one is a static data.
+
+In case a top-level operation isn't specified, the `and` operation is applied.
+It may be changed by specifying another operation though.
+
+### A full example of usage
+
+```javascript
+import { doesMeetConditions } from '@atlassian/forge-conditions';
+
+const conditions = {
+  isLoggedIn: true,
+  or: {
+    isAdmin: true,
+    anotherProp: ['this', 'or', 'whatever'],
+  }
+};
+
+const staticContext = {
+  isLoggedIn: true,
+  isAdmin: false,
+  anotherProp: 'this',
+};
+
+// true, because isLoggedIn matches and one of the `or` conditions matched as well
+doesMeetConditions(conditions, staticContext);
+```
+
+All supported operations can be nested if needed:
+
+```javascript
+const conditions = {
+  or: {
+    isLoggedIn: true,
+    not: {
+      anotherProp: ['O_GOD_NOT_THIS_OH_NO_HELP_NOOOOOO'],
+      and: {
+        isAdmin: true,
+        not: {
+          issueType: 'Bug',
+        }
+      }
+    }
+  }
+};
+```

package/out/check.d.ts

@@ -0,0 +1,3 @@
+import { Conditions, StaticContext, ClientDataProvider } from './types';
+export declare const doesMeetConditions: (conditions: Conditions, staticContext: StaticContext, clientDataProvider?: ClientDataProvider) => Promise<boolean> | boolean;
+//# sourceMappingURL=check.d.ts.map

package/out/check.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"check.d.ts","sourceRoot":"","sources":["../src/check.ts"],"names":[],"mappings":"AAAA,OAAO,EAAkD,UAAU,EAAE,aAAa,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAC;AAoNxH,eAAO,MAAM,kBAAkB,eACjB,UAAU,iBACP,aAAa,uBACP,kBAAkB,KACtC,QAAQ,OAAO,CAAC,GAAG,OAwBrB,CAAC"}

package/out/check.js

@@ -0,0 +1,147 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.doesMeetConditions = void 0;
+const common_1 = require("./common");
+const text_1 = require("./text");
+const entity_property_1 = require("./condition-types/entity-property");
+const unhandledOperation = (operation) => {
+    throw new Error(text_1.errors.unhandledOperation(operation));
+};
+const checkOperation = (operation, conditionsInput, staticContextInput, clientData) => {
+    const conditions = (0, common_1.isObjectOrArray)(conditionsInput) ? conditionsInput : {};
+    const staticContext = (0, common_1.isObject)(staticContextInput) ? staticContextInput : {};
+    let staticKeys = [];
+    let operationEntries = [];
+    let propertyConditions;
+    if (Array.isArray(conditions)) {
+        propertyConditions = conditions;
+    }
+    else {
+        staticKeys = Object.keys(conditions).filter(common_1.isStaticKey);
+        propertyConditions = Object.entries(conditions)
+            .filter(([key]) => (0, common_1.isEntityPropertyCondition)(key))
+            .map(([key, condition]) => ({ [key]: condition }));
+        operationEntries = Object.entries(conditions).filter(([key, _]) => (0, common_1.isOperation)(key));
+    }
+    const staticKeysLength = staticKeys.length;
+    const operationsLength = operationEntries.length;
+    const propertyConditionsLength = propertyConditions.length;
+    const staticEqualityComparator = (key) => (Array.isArray(conditions[key]) ? conditions[key] : [conditions[key]]).includes(staticContext[key]);
+    if (staticKeysLength === 0 && operationsLength === 0 && propertyConditionsLength === 0) {
+        return common_1.Instruction.Skip;
+    }
+    if (staticKeysLength !== 0 || propertyConditionsLength !== 0) {
+        let clientDataConditionResult;
+        switch (operation) {
+            case common_1.AND_OPERATION:
+                if (staticKeysLength && !staticKeys.every(staticEqualityComparator)) {
+                    return false;
+                }
+                clientDataConditionResult = entity_property_1.entityPropertyHandlers[common_1.AND_OPERATION](propertyConditions, clientData);
+                if (clientDataConditionResult !== common_1.Instruction.Continue) {
+                    return clientDataConditionResult;
+                }
+                break;
+            case common_1.OR_OPERATION:
+                if (staticKeysLength && staticKeys.some(staticEqualityComparator)) {
+                    return true;
+                }
+                clientDataConditionResult = entity_property_1.entityPropertyHandlers[common_1.OR_OPERATION](propertyConditions, clientData);
+                if (clientDataConditionResult !== common_1.Instruction.Continue) {
+                    return clientDataConditionResult;
+                }
+                break;
+            case common_1.NOT_OPERATION:
+                if (staticKeysLength && staticKeys.some((key) => !staticEqualityComparator(key))) {
+                    return true;
+                }
+                clientDataConditionResult = entity_property_1.entityPropertyHandlers[common_1.NOT_OPERATION](propertyConditions, clientData);
+                if (clientDataConditionResult !== common_1.Instruction.Continue) {
+                    return clientDataConditionResult;
+                }
+                break;
+            default:
+                return unhandledOperation(operation);
+        }
+    }
+    for (let index = 0; index < operationEntries.length; index += 1) {
+        const [nextOperation, nextConditions] = operationEntries[index];
+        const nextOperationResult = checkOperation(nextOperation, nextConditions, staticContext, clientData);
+        if (nextOperationResult === common_1.Instruction.NeedData) {
+            return nextOperationResult;
+        }
+        switch (operation) {
+            case common_1.AND_OPERATION:
+                if (nextOperationResult === false) {
+                    return false;
+                }
+                if (nextOperationResult === common_1.Instruction.Skip && operationsLength === 1) {
+                    return staticKeysLength + propertyConditionsLength === 0 ? common_1.Instruction.Skip : true;
+                }
+                break;
+            case common_1.OR_OPERATION:
+                if (nextOperationResult === true) {
+                    return true;
+                }
+                if (nextOperationResult === common_1.Instruction.Skip && operationsLength === 1) {
+                    return staticKeysLength + propertyConditionsLength === 0 ? common_1.Instruction.Skip : false;
+                }
+                break;
+            case common_1.NOT_OPERATION:
+                if (nextOperationResult === false) {
+                    return true;
+                }
+                if (nextOperationResult === common_1.Instruction.Skip && operationsLength === 1) {
+                    return staticKeysLength + propertyConditionsLength === 0 ? common_1.Instruction.Skip : false;
+                }
+                break;
+            default:
+                return unhandledOperation(operation);
+        }
+    }
+    switch (operation) {
+        case common_1.AND_OPERATION:
+            return true;
+        case common_1.OR_OPERATION:
+            return false;
+        case common_1.NOT_OPERATION:
+            return false;
+        default:
+            return unhandledOperation(operation);
+    }
+};
+const validateNesting = (conditionsInput, nesting = 0) => {
+    if (nesting >= 10) {
+        throw new Error(text_1.errors.nestingOvercomplicated());
+    }
+    const conditions = (0, common_1.isObjectOrArray)(conditionsInput) ? conditionsInput : {};
+    if (Array.isArray(conditions)) {
+        return;
+    }
+    Object.entries(conditions)
+        .filter(([key, _]) => (0, common_1.isOperation)(key))
+        .forEach(([_, condition]) => validateNesting(condition, nesting + 1));
+};
+const doesMeetConditions = (conditions, staticContext, clientDataProvider) => {
+    try {
+        validateNesting(conditions);
+        let result = checkOperation(common_1.AND_OPERATION, conditions, staticContext);
+        if (result !== common_1.Instruction.NeedData) {
+            return result === common_1.Instruction.Skip ? true : result;
+        }
+        if (!clientDataProvider) {
+            return false;
+        }
+        return clientDataProvider
+            .fetchPropertyValues((0, entity_property_1.collectEntityPropertiesToFetch)(conditions))
+            .then((clientData) => {
+            result = checkOperation(common_1.AND_OPERATION, conditions, staticContext, clientData);
+            return result === common_1.Instruction.Skip ? true : result;
+        })
+            .catch(() => false);
+    }
+    catch (_a) {
+        return false;
+    }
+};
+exports.doesMeetConditions = doesMeetConditions;

package/out/common.d.ts

@@ -0,0 +1,16 @@
+import { AndOperation, NotOperation, OrOperation, PropertyConditionType, SupportedOperations } from './types';
+export declare const AND_OPERATION: AndOperation;
+export declare const OR_OPERATION: OrOperation;
+export declare const NOT_OPERATION: NotOperation;
+export declare const SUPPORTED_OPERATIONS: SupportedOperations;
+export declare enum Instruction {
+    Skip = "skip",
+    NeedData = "need-data",
+    Continue = "continue"
+}
+export declare const isObject: (x: any) => boolean;
+export declare const isObjectOrArray: (x: any) => boolean;
+export declare const isOperation: (key: string) => boolean;
+export declare const isEntityPropertyCondition: (key: string) => key is PropertyConditionType;
+export declare const isStaticKey: (key: string) => boolean;
+//# sourceMappingURL=common.d.ts.map

package/out/common.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"common.d.ts","sourceRoot":"","sources":["../src/common.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EACZ,YAAY,EAEZ,WAAW,EACX,qBAAqB,EACrB,mBAAmB,EACpB,MAAM,SAAS,CAAC;AAEjB,eAAO,MAAM,aAAa,EAAE,YAAoB,CAAC;AACjD,eAAO,MAAM,YAAY,EAAE,WAAkB,CAAC;AAC9C,eAAO,MAAM,aAAa,EAAE,YAAoB,CAAC;AACjD,eAAO,MAAM,oBAAoB,EAAE,mBAAkE,CAAC;AAEtG,oBAAY,WAAW;IACrB,IAAI,SAAS;IACb,QAAQ,cAAc;IACtB,QAAQ,aAAa;CACtB;AAED,eAAO,MAAM,QAAQ,MAAO,GAAG,KAAG,OAAkE,CAAC;AACrG,eAAO,MAAM,eAAe,MAAO,GAAG,KAAG,OAA0C,CAAC;AAEpF,eAAO,MAAM,WAAW,QAAS,MAAM,KAAG,OAA0D,CAAC;AACrG,eAAO,MAAM,yBAAyB,QAAS,MAAM,iCACwB,CAAC;AAC9E,eAAO,MAAM,WAAW,QAAS,MAAM,KAAG,OAA4E,CAAC"}

package/out/common.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isStaticKey = exports.isEntityPropertyCondition = exports.isOperation = exports.isObjectOrArray = exports.isObject = exports.Instruction = exports.SUPPORTED_OPERATIONS = exports.NOT_OPERATION = exports.OR_OPERATION = exports.AND_OPERATION = void 0;
+const types_1 = require("./types");
+exports.AND_OPERATION = 'and';
+exports.OR_OPERATION = 'or';
+exports.NOT_OPERATION = 'not';
+exports.SUPPORTED_OPERATIONS = [exports.AND_OPERATION, exports.OR_OPERATION, exports.NOT_OPERATION];
+var Instruction;
+(function (Instruction) {
+    Instruction["Skip"] = "skip";
+    Instruction["NeedData"] = "need-data";
+    Instruction["Continue"] = "continue";
+})(Instruction = exports.Instruction || (exports.Instruction = {}));
+const isObject = (x) => Object.prototype.toString.call(x) === '[object Object]';
+exports.isObject = isObject;
+const isObjectOrArray = (x) => (0, exports.isObject)(x) || Array.isArray(x);
+exports.isObjectOrArray = isObjectOrArray;
+const isOperation = (key) => exports.SUPPORTED_OPERATIONS.includes(key);
+exports.isOperation = isOperation;
+const isEntityPropertyCondition = (key) => Object.values(types_1.PropertyConditionType).includes(key);
+exports.isEntityPropertyCondition = isEntityPropertyCondition;
+const isStaticKey = (key) => !(0, exports.isOperation)(key) && !(0, exports.isEntityPropertyCondition)(key);
+exports.isStaticKey = isStaticKey;

package/out/condition-types/entity-property.d.ts

@@ -0,0 +1,9 @@
+import { ClientData, Conditions, EntityPropertyCondition, PropertyValueRequest } from '../types';
+import { Instruction } from '../common';
+export declare const entityPropertyHandlers: {
+    and: (propertyConditions: EntityPropertyCondition[], clientData?: ClientData) => boolean | Instruction;
+    or: (propertyConditions: EntityPropertyCondition[], clientData?: ClientData) => boolean | Instruction;
+    not: (propertyConditions: EntityPropertyCondition[], clientData?: ClientData) => boolean | Instruction;
+};
+export declare const collectEntityPropertiesToFetch: (conditionsInput: Conditions) => PropertyValueRequest[];
+//# sourceMappingURL=entity-property.d.ts.map

package/out/condition-types/entity-property.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"entity-property.d.ts","sourceRoot":"","sources":["../../src/condition-types/entity-property.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,UAAU,EACV,UAAU,EAEV,uBAAuB,EAEvB,oBAAoB,EAErB,MAAM,UAAU,CAAC;AAElB,OAAO,EAIL,WAAW,EAIZ,MAAM,WAAW,CAAC;AAiHnB,eAAO,MAAM,sBAAsB;8BAxDb,uBAAuB,EAAE,eAChC,UAAU,KACtB,OAAO,GAAG,WAAW;6BAgBF,uBAAuB,EAAE,eAChC,UAAU,KACtB,OAAO,GAAG,WAAW;8BAgBF,uBAAuB,EAAE,eAChC,UAAU,KACtB,OAAO,GAAG,WAAW;CAsBvB,CAAC;AAgBF,eAAO,MAAM,8BAA8B,oBAAqB,UAAU,KAAG,oBAAoB,EAiChG,CAAC"}

package/out/condition-types/entity-property.js

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.collectEntityPropertiesToFetch = exports.entityPropertyHandlers = void 0;
+const types_1 = require("../types");
+const text_1 = require("../text");
+const common_1 = require("../common");
+const asArray = (value) => (Array.isArray(value) ? value : [value]);
+const entityId = (entityProperty) => [entityProperty.entity, entityProperty.propertyKey, entityProperty.objectName].filter(Boolean).join('-');
+const doesEntityPropertyMatch = (condition, propertyValuesResponse) => {
+    const conditionType = Object.keys(condition)[0];
+    const conditionFields = condition[conditionType];
+    const id = entityId(conditionFields);
+    const propertyValue = propertyValuesResponse[id];
+    const expectedValue = conditionFields.value;
+    let propValueArray;
+    switch (conditionType) {
+        case types_1.PropertyConditionType.EntityPropertyExists:
+            return propertyValue != null;
+        case types_1.PropertyConditionType.EntityPropertyEqualTo:
+            return propertyValue === expectedValue;
+        case types_1.PropertyConditionType.EntityPropertyContainsAny:
+            propValueArray = asArray(propertyValue);
+            return asArray(expectedValue).some((expected) => propValueArray.includes(expected));
+        case types_1.PropertyConditionType.EntityPropertyContainsAll:
+            propValueArray = asArray(propertyValue);
+            return asArray(expectedValue).every((expected) => propValueArray.includes(expected));
+        default:
+            throw new Error(text_1.errors.unsupportedConditionType(conditionType));
+    }
+};
+const clientConditionsPreCheck = (clientDataConditionsLength, clientData) => {
+    if (!clientDataConditionsLength) {
+        return common_1.Instruction.Continue;
+    }
+    if (!clientData) {
+        return common_1.Instruction.NeedData;
+    }
+};
+const entityPropertyAndHandler = (propertyConditions, clientData) => {
+    const preCheck = clientConditionsPreCheck(propertyConditions.length, clientData);
+    if (preCheck) {
+        return preCheck;
+    }
+    if (!propertyConditions.every((propCondition) => doesEntityPropertyMatch(propCondition, clientData.propertyValues))) {
+        return false;
+    }
+    return common_1.Instruction.Continue;
+};
+const entityPropertyOrHandler = (propertyConditions, clientData) => {
+    const preCheck = clientConditionsPreCheck(propertyConditions.length, clientData);
+    if (preCheck) {
+        return preCheck;
+    }
+    if (propertyConditions.some((propCondition) => doesEntityPropertyMatch(propCondition, clientData.propertyValues))) {
+        return true;
+    }
+    return common_1.Instruction.Continue;
+};
+const entityPropertyNotHandler = (propertyConditions, clientData) => {
+    const preCheck = clientConditionsPreCheck(propertyConditions.length, clientData);
+    if (preCheck) {
+        return preCheck;
+    }
+    if (propertyConditions.some((propCondition) => !doesEntityPropertyMatch(propCondition, clientData.propertyValues))) {
+        return true;
+    }
+    return common_1.Instruction.Continue;
+};
+exports.entityPropertyHandlers = {
+    [common_1.AND_OPERATION]: entityPropertyAndHandler,
+    [common_1.OR_OPERATION]: entityPropertyOrHandler,
+    [common_1.NOT_OPERATION]: entityPropertyNotHandler
+};
+const buildPropertyValueRequest = (entityProperty) => {
+    return Object.assign({ id: entityId(entityProperty), entity: entityProperty.entity, propertyKey: entityProperty.propertyKey }, (entityProperty.objectName && { objectName: entityProperty.objectName }));
+};
+const collectEntityPropertiesToFetch = (conditionsInput) => {
+    const conditions = (0, common_1.isObjectOrArray)(conditionsInput) ? conditionsInput : {};
+    const propertyRequests = [];
+    if (Array.isArray(conditions)) {
+        for (const propertyCondition of conditions) {
+            const key = Object.keys(propertyCondition).find(common_1.isEntityPropertyCondition);
+            if (key) {
+                const entityProperty = propertyCondition[key];
+                propertyRequests.push(buildPropertyValueRequest(entityProperty));
+            }
+        }
+        return propertyRequests;
+    }
+    Object.entries(conditions)
+        .filter(([key, _]) => (0, common_1.isEntityPropertyCondition)(key))
+        .forEach(([_, condition]) => propertyRequests.push(buildPropertyValueRequest(condition)));
+    Object.entries(conditions)
+        .filter(([key, _]) => (0, common_1.isOperation)(key))
+        .forEach(([_, condition]) => propertyRequests.push(...(0, exports.collectEntityPropertiesToFetch)(condition)));
+    return propertyRequests;
+};
+exports.collectEntityPropertiesToFetch = collectEntityPropertiesToFetch;

package/out/index.d.ts

@@ -0,0 +1,3 @@
+export * from './check';
+export * from './types';
+//# sourceMappingURL=index.d.ts.map

package/out/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,SAAS,CAAC;AACxB,cAAc,SAAS,CAAC"}

package/out/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./check"), exports);
+tslib_1.__exportStar(require("./types"), exports);

package/out/text.d.ts

@@ -0,0 +1,7 @@
+import { PropertyConditionType } from './types';
+export declare const errors: {
+    nestingOvercomplicated: () => string;
+    unhandledOperation: (operation: never) => string;
+    unsupportedConditionType: (conditionType: PropertyConditionType) => string;
+};
+//# sourceMappingURL=text.d.ts.map

package/out/text.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"text.d.ts","sourceRoot":"","sources":["../src/text.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAC;AAEhD,eAAO,MAAM,MAAM;kCACW,MAAM;oCACF,KAAK,KAAG,MAAM;8CACJ,qBAAqB,KAAG,MAAM;CAEzE,CAAC"}

package/out/text.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.errors = void 0;
+exports.errors = {
+    nestingOvercomplicated: () => 'Nesting of display conditions exceeds 10 levels',
+    unhandledOperation: (operation) => `Unhandled operation: ${operation}`,
+    unsupportedConditionType: (conditionType) => `Unsupported condition type: ${conditionType}`
+};

package/out/types.d.ts

@@ -0,0 +1,62 @@
+export declare type AndOperation = 'and';
+export declare type OrOperation = 'or';
+export declare type NotOperation = 'not';
+export declare type Operation = AndOperation | OrOperation | NotOperation;
+export declare type SupportedOperations = [AndOperation, OrOperation, NotOperation];
+export declare type GenericCondition<T> = AndCondition<T> | OrCondition<T> | NotCondition<T> | T;
+export declare type AndCondition<T> = T & {
+    [key in AndOperation]: GenericCondition<T>;
+};
+export declare type OrCondition<T> = T & {
+    [key in OrOperation]: GenericCondition<T>;
+};
+export declare type NotCondition<T> = T & {
+    [key in NotOperation]: GenericCondition<T>;
+};
+export declare enum PropertyConditionType {
+    EntityPropertyExists = "entityPropertyExists",
+    EntityPropertyEqualTo = "entityPropertyEqualTo",
+    EntityPropertyContainsAny = "entityPropertyContainsAny",
+    EntityPropertyContainsAll = "entityPropertyContainsAll"
+}
+export declare enum EntityType {
+    Space = "space",
+    Content = "content"
+}
+export interface EntityProperty {
+    entity: EntityType;
+    propertyKey: string;
+    objectName?: string;
+    value: string | string[];
+}
+export declare type EntityPropertyCondition = {
+    [key in PropertyConditionType]?: EntityProperty;
+};
+export interface PropertyValueRequest {
+    id: string;
+    entity: EntityType;
+    propertyKey: string;
+    objectName?: string;
+}
+export interface PropertyValuesResponse {
+    [id: string]: string | string[];
+}
+export interface ClientData {
+    propertyValues: PropertyValuesResponse;
+}
+export declare class ClientDataProvider {
+    private readonly globalFetchPromise;
+    private globalFetchResolve?;
+    private globalFetchReject?;
+    propertyValueRequests: PropertyValueRequest[];
+    constructor();
+    fetchPropertyValues(propValueRequests: PropertyValueRequest[]): Promise<ClientData>;
+    resolve(clientData: ClientData): void;
+    reject(reason: any): void;
+}
+export declare type Condition = StaticContext | (StaticContext & EntityPropertyCondition) | EntityPropertyCondition[];
+export declare type Conditions = GenericCondition<Condition>;
+export declare type StaticContext = {
+    [key in string]: any;
+};
+//# sourceMappingURL=types.d.ts.map

package/out/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAEA,oBAAY,YAAY,GAAG,KAAK,CAAC;AACjC,oBAAY,WAAW,GAAG,IAAI,CAAC;AAC/B,oBAAY,YAAY,GAAG,KAAK,CAAC;AAEjC,oBAAY,SAAS,GAAG,YAAY,GAAG,WAAW,GAAG,YAAY,CAAC;AAClE,oBAAY,mBAAmB,GAAG,CAAC,YAAY,EAAE,WAAW,EAAE,YAAY,CAAC,CAAC;AAE5E,oBAAY,gBAAgB,CAAC,CAAC,IAAI,YAAY,CAAC,CAAC,CAAC,GAAG,WAAW,CAAC,CAAC,CAAC,GAAG,YAAY,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;AACzF,oBAAY,YAAY,CAAC,CAAC,IAAI,CAAC,GAAG;KAC/B,GAAG,IAAI,YAAY,GAAG,gBAAgB,CAAC,CAAC,CAAC;CAC3C,CAAC;AAEF,oBAAY,WAAW,CAAC,CAAC,IAAI,CAAC,GAAG;KAC9B,GAAG,IAAI,WAAW,GAAG,gBAAgB,CAAC,CAAC,CAAC;CAC1C,CAAC;AAEF,oBAAY,YAAY,CAAC,CAAC,IAAI,CAAC,GAAG;KAC/B,GAAG,IAAI,YAAY,GAAG,gBAAgB,CAAC,CAAC,CAAC;CAC3C,CAAC;AAEF,oBAAY,qBAAqB;IAC/B,oBAAoB,yBAAyB;IAC7C,qBAAqB,0BAA0B;IAC/C,yBAAyB,8BAA8B;IACvD,yBAAyB,8BAA8B;CACxD;AAED,oBAAY,UAAU;IACpB,KAAK,UAAU;IACf,OAAO,YAAY;CACpB;AAKD,MAAM,WAAW,cAAc;IAC7B,MAAM,EAAE,UAAU,CAAC;IACnB,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;CAC1B;AAKD,oBAAY,uBAAuB,GAAG;KACnC,GAAG,IAAI,qBAAqB,CAAC,CAAC,EAAE,cAAc;CAChD,CAAC;AAKF,MAAM,WAAW,oBAAoB;IAInC,EAAE,EAAE,MAAM,CAAC;IAIX,MAAM,EAAE,UAAU,CAAC;IAInB,WAAW,EAAE,MAAM,CAAC;IAKpB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAWD,MAAM,WAAW,sBAAsB;IACrC,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,EAAE,CAAC;CACjC;AAKD,MAAM,WAAW,UAAU;IACzB,cAAc,EAAE,sBAAsB,CAAC;CACxC;AAaD,qBAAa,kBAAkB;IAC7B,OAAO,CAAC,QAAQ,CAAC,kBAAkB,CAAsB;IACzD,OAAO,CAAC,kBAAkB,CAAC,CAA8B;IACzD,OAAO,CAAC,iBAAiB,CAAC,CAAwB;IAKlD,qBAAqB,EAAE,oBAAoB,EAAE,CAAC;;IAe9C,mBAAmB,CAAC,iBAAiB,EAAE,oBAAoB,EAAE,GAAG,OAAO,CAAC,UAAU,CAAC;IAanF,OAAO,CAAC,UAAU,EAAE,UAAU,GAAG,IAAI;IAYrC,MAAM,CAAC,MAAM,EAAE,GAAG,GAAG,IAAI;CAG1B;AAQD,oBAAY,SAAS,GAAG,aAAa,GAAG,CAAC,aAAa,GAAG,uBAAuB,CAAC,GAAG,uBAAuB,EAAE,CAAC;AAK9G,oBAAY,UAAU,GAAG,gBAAgB,CAAC,SAAS,CAAC,CAAC;AAQrD,oBAAY,aAAa,GAAG;KACzB,GAAG,IAAI,MAAM,GAAG,GAAG;CACrB,CAAC"}

package/out/types.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClientDataProvider = exports.EntityType = exports.PropertyConditionType = void 0;
+var PropertyConditionType;
+(function (PropertyConditionType) {
+    PropertyConditionType["EntityPropertyExists"] = "entityPropertyExists";
+    PropertyConditionType["EntityPropertyEqualTo"] = "entityPropertyEqualTo";
+    PropertyConditionType["EntityPropertyContainsAny"] = "entityPropertyContainsAny";
+    PropertyConditionType["EntityPropertyContainsAll"] = "entityPropertyContainsAll";
+})(PropertyConditionType = exports.PropertyConditionType || (exports.PropertyConditionType = {}));
+var EntityType;
+(function (EntityType) {
+    EntityType["Space"] = "space";
+    EntityType["Content"] = "content";
+})(EntityType = exports.EntityType || (exports.EntityType = {}));
+class ClientDataProvider {
+    constructor() {
+        this.globalFetchPromise = new Promise((resolve, reject) => {
+            this.globalFetchResolve = resolve;
+            this.globalFetchReject = reject;
+        });
+        this.propertyValueRequests = [];
+    }
+    fetchPropertyValues(propValueRequests) {
+        this.propertyValueRequests.push(...propValueRequests);
+        return this.globalFetchPromise;
+    }
+    resolve(clientData) {
+        var _a;
+        (_a = this.globalFetchResolve) === null || _a === void 0 ? void 0 : _a.call(this, clientData);
+    }
+    reject(reason) {
+        var _a;
+        (_a = this.globalFetchReject) === null || _a === void 0 ? void 0 : _a.call(this, reason);
+    }
+}
+exports.ClientDataProvider = ClientDataProvider;

package/package.json

@@ -0,0 +1,15 @@
+{
+  "name": "@atlassian/forge-conditions",
+  "version": "0.3.3-next.0",
+  "description": "Support conditions in the forge apps",
+  "main": "out/index.js",
+  "license": "SEE LICENSE IN LICENSE.txt",
+  "scripts": {
+    "build": "yarn run clean && yarn run compile",
+    "compile": "tsc -b -v",
+    "clean": "rm -rf ./out && rm -f tsconfig.tsbuildinfo"
+  },
+  "publishConfig": {
+    "registry": "https://packages.atlassian.com/api/npm/npm-public/"
+  }
+}