commandbar 1.6.13 → 1.6.14

package/build/internal/src/middleware/helpers/argument.d.ts

@@ -53,19 +53,21 @@ export declare const SetArgumentV: t.IntersectionC<[t.TypeC<{
     auto_choose: t.BooleanC;
     is_private: t.BooleanC;
 }>]>;
-export declare const VideoDashboardV: t.IntersectionC<[t.TypeC<{
+export declare const DashboardV: t.IntersectionC<[t.TypeC<{
     source: t.StringC;
 }>, t.PartialC<{
     title: t.StringC;
     description: t.StringC;
+    url: t.StringC;
 }>]>;
-export declare const VideoArgumentV: t.IntersectionC<[t.TypeC<{
-    type: t.LiteralC<"video">;
+export declare const DashboardArgumentV: t.IntersectionC<[t.TypeC<{
+    type: t.UnionC<[t.LiteralC<"video">, t.LiteralC<"html">]>;
     value: t.IntersectionC<[t.TypeC<{
         source: t.StringC;
     }>, t.PartialC<{
         title: t.StringC;
         description: t.StringC;
+        url: t.StringC;
     }>]>;
     order_key: t.NumberC;
 }>, t.PartialC<{
@@ -262,12 +264,13 @@ export declare const ArgumentTypeV: t.UnionC<[t.IntersectionC<[t.TypeC<{
     auto_choose: t.BooleanC;
     is_private: t.BooleanC;
 }>]>, t.IntersectionC<[t.TypeC<{
-    type: t.LiteralC<"video">;
+    type: t.UnionC<[t.LiteralC<"video">, t.LiteralC<"html">]>;
     value: t.IntersectionC<[t.TypeC<{
         source: t.StringC;
     }>, t.PartialC<{
         title: t.StringC;
         description: t.StringC;
+        url: t.StringC;
     }>]>;
     order_key: t.NumberC;
 }>, t.PartialC<{
@@ -397,12 +400,13 @@ export declare const ArgumentMapV: t.RecordC<t.StringC, t.UnionC<[t.Intersection
     auto_choose: t.BooleanC;
     is_private: t.BooleanC;
 }>]>, t.IntersectionC<[t.TypeC<{
-    type: t.LiteralC<"video">;
+    type: t.UnionC<[t.LiteralC<"video">, t.LiteralC<"html">]>;
     value: t.IntersectionC<[t.TypeC<{
         source: t.StringC;
     }>, t.PartialC<{
         title: t.StringC;
         description: t.StringC;
+        url: t.StringC;
     }>]>;
     order_key: t.NumberC;
 }>, t.PartialC<{
@@ -535,12 +539,13 @@ export declare const StepArgumentTypeV: t.IntersectionC<[t.TypeC<{
     auto_choose: t.BooleanC;
     is_private: t.BooleanC;
 }>]>, t.IntersectionC<[t.TypeC<{
-    type: t.LiteralC<"video">;
+    type: t.UnionC<[t.LiteralC<"video">, t.LiteralC<"html">]>;
     value: t.IntersectionC<[t.TypeC<{
         source: t.StringC;
     }>, t.PartialC<{
         title: t.StringC;
         description: t.StringC;
+        url: t.StringC;
     }>]>;
     order_key: t.NumberC;
 }>, t.PartialC<{

package/build/internal/src/middleware/helpers/commandTemplate.d.ts

@@ -88,6 +88,15 @@ export declare const VideoTemplateV: t.IntersectionC<[t.TypeC<{
     hoverTooltip: t.BooleanC;
     operation: t.UnionC<[t.LiteralC<"router">, t.LiteralC<"self">, t.LiteralC<"blank">, t.UndefinedC]>;
 }>]>]>;
+export declare const HelpDocTemplateV: t.IntersectionC<[t.TypeC<{
+    type: t.LiteralC<"helpdoc">;
+    value: t.StringC;
+}>, t.IntersectionC<[t.TypeC<{}>, t.PartialC<{
+    commandType: t.UnionC<[t.LiteralC<"independent">, t.LiteralC<"object">, t.LiteralC<"help">]>;
+    object: t.StringC;
+    hoverTooltip: t.BooleanC;
+    operation: t.UnionC<[t.LiteralC<"router">, t.LiteralC<"self">, t.LiteralC<"blank">, t.UndefinedC]>;
+}>]>]>;
 export declare const RequestV: t.IntersectionC<[t.TypeC<{
     method: t.UnionC<[t.LiteralC<"get">, t.LiteralC<"delete">, t.LiteralC<"head">, t.LiteralC<"options">, t.LiteralC<"post">, t.LiteralC<"put">, t.LiteralC<"patch">]>;
     url: t.StringC;
@@ -205,4 +214,12 @@ export declare const TemplateV: t.UnionC<[t.IntersectionC<[t.TypeC<{
     object: t.StringC;
     hoverTooltip: t.BooleanC;
     operation: t.UnionC<[t.LiteralC<"router">, t.LiteralC<"self">, t.LiteralC<"blank">, t.UndefinedC]>;
+}>]>]>, t.IntersectionC<[t.TypeC<{
+    type: t.LiteralC<"helpdoc">;
+    value: t.StringC;
+}>, t.IntersectionC<[t.TypeC<{}>, t.PartialC<{
+    commandType: t.UnionC<[t.LiteralC<"independent">, t.LiteralC<"object">, t.LiteralC<"help">]>;
+    object: t.StringC;
+    hoverTooltip: t.BooleanC;
+    operation: t.UnionC<[t.LiteralC<"router">, t.LiteralC<"self">, t.LiteralC<"blank">, t.UndefinedC]>;
 }>]>]>]>;

package/build/internal/src/middleware/helpers/rules.d.ts

@@ -45,6 +45,34 @@ export declare const ConditionV: t.IntersectionC<[t.TypeC<{
     value: t.StringC;
     reason: t.StringC;
 }>]>;
+export declare const getConditions: (expr: RuleExpression) => ExpressionCondition[];
+export declare const canonicalize: (expr: RuleExpression) => RuleExpression;
+export declare function isCompoundExpression(expr: RuleExpression): expr is RuleExpressionAnd | RuleExpressionOr;
+export declare type ExpressionCondition = t.TypeOf<typeof ConditionV> | t.TypeOf<typeof NamedRuleReferenceV>;
+export declare type RuleExpression = RuleExpressionAnd | RuleExpressionOr | RuleExpressionLiteral | RuleExpressionCondition;
+export declare type RuleExpressionAnd = {
+    type: 'AND';
+    exprs: RuleExpression[];
+};
+export declare type RuleExpressionOr = {
+    type: 'OR';
+    exprs: RuleExpression[];
+};
+export declare type RuleExpressionLiteral = {
+    type: 'LITERAL';
+    value: boolean;
+};
+export declare type RuleExpressionCondition = {
+    type: 'CONDITION';
+    condition: ExpressionCondition;
+};
+export declare const RuleExpressionAndV: t.Type<RuleExpressionAnd>;
+export declare const RuleExpressionOrV: t.Type<RuleExpressionOr>;
+export declare const RuleExpressionLiteralV: t.Type<RuleExpressionLiteral>;
+export declare const RuleExpressionConditionV: t.Type<RuleExpressionCondition>;
+export declare const RuleExpressionV: t.Type<RuleExpression>;
+export declare const RuleExpressionTrue: t.TypeOf<typeof RuleExpressionLiteralV>;
+export declare const RuleExpressionFalse: t.TypeOf<typeof RuleExpressionLiteralV>;
 export declare const NamedRuleReferenceV: t.IntersectionC<[t.TypeC<{
     type: t.LiteralC<"named_rule">;
     rule_id: t.NumberC;
@@ -190,32 +218,7 @@ export declare const EditorRecommendationRuleV: t.UnionC<[t.UnionC<[t.Intersecti
 export declare const NamedRuleV: t.TypeC<{
     id: t.NumberC;
     name: t.StringC;
-    conditions: t.ArrayC<t.IntersectionC<[t.TypeC<{
-        type: t.UnionC<[t.LiteralC<"context">, t.LiteralC<"url">, t.LiteralC<"element">]>;
-        operator: t.KeyofC<{
-            includes: null;
-            endsWith: null;
-            startsWith: null;
-            is: null;
-            isTruthy: null;
-            isFalsy: null;
-            isNot: null;
-            isTrue: null;
-            isFalse: null;
-            doesNotInclude: null;
-            matchesRegex: null;
-            isGreaterThan: null;
-            isLessThan: null;
-            isDefined: null;
-            isNotDefined: null;
-            classnameOnPage: null;
-            idOnPage: null;
-        }>;
-    }>, t.PartialC<{
-        field: t.StringC;
-        value: t.StringC;
-        reason: t.StringC;
-    }>]>>;
+    expression: t.Type<RuleExpression, RuleExpression, unknown>;
 }>;
 export declare type IRuleOperator = t.TypeOf<typeof OperatorV>;
 export declare type IAvailabilityRule = t.TypeOf<typeof AvailabilityRuleV>;

package/build/internal/src/middleware/nudge.d.ts

@@ -0,0 +1,189 @@
+import * as t from 'io-ts';
+export declare const NudgeV: t.IntersectionC<[t.TypeC<{
+    id: t.NumberC;
+    organization: t.StringC;
+    slug: t.StringC;
+    content: t.StringC;
+    show_expression: t.Type<import("./helpers/rules").RuleExpression, import("./helpers/rules").RuleExpression, unknown>;
+    trigger: t.UnionC<[t.TypeC<{
+        type: t.LiteralC<"when_conditions_pass">;
+    }>, t.TypeC<{
+        type: t.LiteralC<"on_command_execution">;
+        meta: t.TypeC<{
+            command: t.StringC;
+        }>;
+    }>]>;
+    on_select: t.TypeC<{
+        type: t.LiteralC<"execute_command">;
+        meta: t.TypeC<{
+            command: t.StringC;
+        }>;
+    }>;
+    timeout_ms: t.UnionC<[t.NumberC, t.NullC]>;
+    frequency_limit: t.UnionC<[t.LiteralC<"no_limit">, t.LiteralC<"once_per_session">, t.LiteralC<"once_per_user">]>;
+}>, t.PartialC<{}>]>;
+export declare class Nudge {
+    static decode: (data: any) => {
+        id: number;
+        organization: string;
+        slug: string;
+        content: string;
+        show_expression: import("./helpers/rules").RuleExpression;
+        trigger: {
+            type: "when_conditions_pass";
+        } | {
+            type: "on_command_execution";
+            meta: {
+                command: string;
+            };
+        };
+        on_select: {
+            type: "execute_command";
+            meta: {
+                command: string;
+            };
+        };
+        timeout_ms: number | null;
+        frequency_limit: "no_limit" | "once_per_session" | "once_per_user";
+    } & {};
+    static create: (object: {
+        id: number;
+        organization: string;
+        slug: string;
+        content: string;
+        show_expression: import("./helpers/rules").RuleExpression;
+        trigger: {
+            type: "when_conditions_pass";
+        } | {
+            type: "on_command_execution";
+            meta: {
+                command: string;
+            };
+        };
+        on_select: {
+            type: "execute_command";
+            meta: {
+                command: string;
+            };
+        };
+        timeout_ms: number | null;
+        frequency_limit: "no_limit" | "once_per_session" | "once_per_user";
+    } & {}, onSuccess?: (() => void) | undefined, onError?: ((err: string) => void) | undefined) => Promise<{
+        id: number;
+        organization: string;
+        slug: string;
+        content: string;
+        show_expression: import("./helpers/rules").RuleExpression;
+        trigger: {
+            type: "when_conditions_pass";
+        } | {
+            type: "on_command_execution";
+            meta: {
+                command: string;
+            };
+        };
+        on_select: {
+            type: "execute_command";
+            meta: {
+                command: string;
+            };
+        };
+        timeout_ms: number | null;
+        frequency_limit: "no_limit" | "once_per_session" | "once_per_user";
+    } & {}>;
+    static update: (object: {
+        id: number;
+        organization: string;
+        slug: string;
+        content: string;
+        show_expression: import("./helpers/rules").RuleExpression;
+        trigger: {
+            type: "when_conditions_pass";
+        } | {
+            type: "on_command_execution";
+            meta: {
+                command: string;
+            };
+        };
+        on_select: {
+            type: "execute_command";
+            meta: {
+                command: string;
+            };
+        };
+        timeout_ms: number | null;
+        frequency_limit: "no_limit" | "once_per_session" | "once_per_user";
+    } & {}, onSuccess?: (() => void) | undefined, onError?: ((err: string) => void) | undefined) => Promise<{
+        id: number;
+        organization: string;
+        slug: string;
+        content: string;
+        show_expression: import("./helpers/rules").RuleExpression;
+        trigger: {
+            type: "when_conditions_pass";
+        } | {
+            type: "on_command_execution";
+            meta: {
+                command: string;
+            };
+        };
+        on_select: {
+            type: "execute_command";
+            meta: {
+                command: string;
+            };
+        };
+        timeout_ms: number | null;
+        frequency_limit: "no_limit" | "once_per_session" | "once_per_user";
+    } & {}>;
+    static delete: (id: string | number, onSuccess?: (() => void) | undefined, onError?: ((err: string) => void) | undefined) => Promise<void>;
+    static list: (onSuccess?: (() => void) | undefined, onError?: ((err: string) => void) | undefined) => Promise<({
+        id: number;
+        organization: string;
+        slug: string;
+        content: string;
+        show_expression: import("./helpers/rules").RuleExpression;
+        trigger: {
+            type: "when_conditions_pass";
+        } | {
+            type: "on_command_execution";
+            meta: {
+                command: string;
+            };
+        };
+        on_select: {
+            type: "execute_command";
+            meta: {
+                command: string;
+            };
+        };
+        timeout_ms: number | null;
+        frequency_limit: "no_limit" | "once_per_session" | "once_per_user";
+    } & {})[]>;
+    static read: (arg0: string, params?: Record<string, string> | undefined, callbacks?: {
+        onSuccess?: (() => void) | undefined;
+        onError?: ((err: string) => void) | undefined;
+    } | undefined) => Promise<{
+        id: number;
+        organization: string;
+        slug: string;
+        content: string;
+        show_expression: import("./helpers/rules").RuleExpression;
+        trigger: {
+            type: "when_conditions_pass";
+        } | {
+            type: "on_command_execution";
+            meta: {
+                command: string;
+            };
+        };
+        on_select: {
+            type: "execute_command";
+            meta: {
+                command: string;
+            };
+        };
+        timeout_ms: number | null;
+        frequency_limit: "no_limit" | "once_per_session" | "once_per_user";
+    } & {}>;
+}

package/build/internal/src/middleware/organization.d.ts

@@ -352,6 +352,14 @@ export declare class Organization {
             object?: string | undefined;
             hoverTooltip?: boolean | undefined;
             operation?: "self" | "router" | "blank" | undefined;
+        }) | ({
+            type: "helpdoc";
+            value: string;
+        } & {} & {
+            commandType?: "object" | "independent" | "help" | undefined;
+            object?: string | undefined;
+            hoverTooltip?: boolean | undefined;
+            operation?: "self" | "router" | "blank" | undefined;
         });
     } & {
         disabledReason?: string | undefined;
@@ -472,12 +480,13 @@ export declare class Organization {
                 auto_choose?: boolean | undefined;
                 is_private?: boolean | undefined;
             }) | ({
-                type: "video";
+                type: "html" | "video";
                 value: {
                     source: string;
                 } & {
                     title?: string | undefined;
                     description?: string | undefined;
+                    url?: string | undefined;
                 };
                 order_key: number;
             } & {
@@ -507,22 +516,56 @@ export declare class Organization {
             field?: string | undefined;
             value?: string | undefined;
             reason?: string | undefined;
-        })[];
+        })[] | (({
+            type: "url" | "context" | "element";
+            operator: "includes" | "endsWith" | "startsWith" | "is" | "isTruthy" | "isFalsy" | "isNot" | "isTrue" | "isFalse" | "doesNotInclude" | "matchesRegex" | "isGreaterThan" | "isLessThan" | "isDefined" | "isNotDefined" | "classnameOnPage" | "idOnPage";
+        } & {
+            field?: string | undefined;
+            value?: string | undefined;
+            reason?: string | undefined;
+        }) | ({
+            type: "named_rule";
+            rule_id: number;
+        } & {
+            reason?: string | undefined;
+        }))[];
         recommend_rules: (({
+            type: "url" | "context" | "element";
+            operator: "includes" | "endsWith" | "startsWith" | "is" | "isTruthy" | "isFalsy" | "isNot" | "isTrue" | "isFalse" | "doesNotInclude" | "matchesRegex" | "isGreaterThan" | "isLessThan" | "isDefined" | "isNotDefined" | "classnameOnPage" | "idOnPage";
+        } & {
+            field?: string | undefined;
+            value?: string | undefined;
+            reason?: string | undefined;
+        }) | ({
             type: "always";
         } & {
             operator?: null | undefined;
             field?: null | undefined;
             value?: null | undefined;
             reason?: null | undefined;
-        }) | ({
+        }))[] | (({
             type: "url" | "context" | "element";
             operator: "includes" | "endsWith" | "startsWith" | "is" | "isTruthy" | "isFalsy" | "isNot" | "isTrue" | "isFalse" | "doesNotInclude" | "matchesRegex" | "isGreaterThan" | "isLessThan" | "isDefined" | "isNotDefined" | "classnameOnPage" | "idOnPage";
         } & {
             field?: string | undefined;
             value?: string | undefined;
             reason?: string | undefined;
+        }) | ({
+            type: "named_rule";
+            rule_id: number;
+        } & {
+            reason?: string | undefined;
+        }) | ({
+            type: "always";
+        } & {
+            operator?: null | undefined;
+            field?: null | undefined;
+            value?: null | undefined;
+            reason?: null | undefined;
         }))[];
+        availability_expression: import("./helpers/rules").RuleExpression;
+        recommend_expression: import("./helpers/rules").RuleExpression;
+        always_recommend: boolean;
         confirm: string;
         shortcut: string[];
         explanation: string;
@@ -561,6 +604,10 @@ export declare class Organization {
         } & {
             position?: "inline" | "popover" | undefined;
         }))[] | null;
+        next_steps: (string | number)[];
+    } & {
+        third_party_source?: string | null | undefined;
+        third_party_id?: string | null | undefined;
     })[]>;
     static listCommandCategories: (orgUID: string) => Promise<({
         id: number;
@@ -604,14 +651,7 @@ export declare class Organization {
     static listRules: (orgUID: string) => Promise<{
         id: number;
         name: string;
-        conditions: ({
-            type: "url" | "context" | "element";
-            operator: "includes" | "endsWith" | "startsWith" | "is" | "isTruthy" | "isFalsy" | "isNot" | "isTrue" | "isFalse" | "doesNotInclude" | "matchesRegex" | "isGreaterThan" | "isLessThan" | "isDefined" | "isNotDefined" | "classnameOnPage" | "idOnPage";
-        } & {
-            field?: string | undefined;
-            value?: string | undefined;
-            reason?: string | undefined;
-        })[];
+        expression: import("./helpers/rules").RuleExpression;
     }[]>;
     static userHasAccess: (uuid: string, user: string) => Promise<{
         username: string;

package/build/internal/src/middleware/types.d.ts

@@ -19,6 +19,8 @@ import { ProfileV } from './profile';
 import { PlaceholderV } from './placeholder';
 import { EnvReleaseInfoV, ReleaseStepV, ReleaseV } from './releases';
 import { EnvironmentV } from './environment';
+import { NudgeV } from './nudge';
+import { RuleExpressionAndV, RuleExpressionOrV, RuleExpressionV } from './helpers/rules';
 /*******************************************************************************/
 export declare type IContextType = t.TypeOf<typeof ContextV>;
 export declare type IUserType = t.TypeOf<typeof UserV>;
@@ -58,6 +60,9 @@ export declare type RequestTemplateType = t.TypeOf<typeof RequestTemplateV>;
 export declare type RequestType = t.TypeOf<typeof RequestV>;
 export declare type ITemplateOptions = t.TypeOf<typeof TemplateOptionsV>;
 export declare type IEndUserType = t.TypeOf<typeof EndUserV>;
+export declare type IRuleExpression = t.TypeOf<typeof RuleExpressionV>;
+export declare type IRuleExpressionAnd = t.TypeOf<typeof RuleExpressionAndV>;
+export declare type IRuleExpressionOr = t.TypeOf<typeof RuleExpressionOrV>;
 export declare type IConditionType = t.TypeOf<typeof ConditionV>;
 export declare type IConditionOperatorType = t.TypeOf<typeof ConditionOperatorV>;
 export declare type IContextArgumentType = t.TypeOf<typeof ContextArgumentV>;
@@ -66,6 +71,12 @@ export declare type IDynamicArgumentType = t.TypeOf<typeof DynamicArgumentV>;
 export declare type IDependentArgumentType = t.TypeOf<typeof DependentArgumentV>;
 export declare type IFunctionArgumentType = t.TypeOf<typeof FunctionArgumentV>;
 export declare type OptionGroupRenderAsType = t.TypeOf<typeof OptionGroupRenderAsV>;
+export declare type INudgeType = t.TypeOf<typeof NudgeV>;
+export interface INudgeClientType {
+    nudge: INudgeType;
+    active: boolean;
+    lastTriggeredTs?: number;
+}
 export interface ICommandInput {
     text: string;
     command: ICommandType;
@@ -96,6 +107,7 @@ export declare type IConfigEndpointResponse = {
     organization: any;
     environments_with_versions?: any[];
     placeholders?: any[];
+    nudges?: INudgeType[];
 };
 export type { IResourceSettings } from './IResourceSettings';
 export declare type IResourceSettingsByContextKey = t.TypeOf<typeof ResourceSettingsByContextKeyV>;
@@ -198,6 +210,14 @@ export declare const isCommand: (command?: ICommandType | any) => command is {
         object?: string | undefined;
         hoverTooltip?: boolean | undefined;
         operation?: "self" | "router" | "blank" | undefined;
+    }) | ({
+        type: "helpdoc";
+        value: string;
+    } & {} & {
+        commandType?: "object" | "independent" | "help" | undefined;
+        object?: string | undefined;
+        hoverTooltip?: boolean | undefined;
+        operation?: "self" | "router" | "blank" | undefined;
     });
 } & {
     disabledReason?: string | undefined;
@@ -318,12 +338,13 @@ export declare const isCommand: (command?: ICommandType | any) => command is {
             auto_choose?: boolean | undefined;
             is_private?: boolean | undefined;
         }) | ({
-            type: "video";
+            type: "html" | "video";
             value: {
                 source: string;
             } & {
                 title?: string | undefined;
                 description?: string | undefined;
+                url?: string | undefined;
             };
             order_key: number;
         } & {
@@ -355,20 +376,23 @@ export declare const isCommand: (command?: ICommandType | any) => command is {
         reason?: string | undefined;
     })[];
     recommend_rules: (({
-        type: "always";
-    } & {
-        operator?: null | undefined;
-        field?: null | undefined;
-        value?: null | undefined;
-        reason?: null | undefined;
-    }) | ({
         type: "url" | "context" | "element";
         operator: "includes" | "endsWith" | "startsWith" | "is" | "isTruthy" | "isFalsy" | "isNot" | "isTrue" | "isFalse" | "doesNotInclude" | "matchesRegex" | "isGreaterThan" | "isLessThan" | "isDefined" | "isNotDefined" | "classnameOnPage" | "idOnPage";
     } & {
         field?: string | undefined;
         value?: string | undefined;
         reason?: string | undefined;
+    }) | ({
+        type: "always";
+    } & {
+        operator?: null | undefined;
+        field?: null | undefined;
+        value?: null | undefined;
+        reason?: null | undefined;
     }))[];
+    availability_expression: import("./helpers/rules").RuleExpression | null;
+    recommend_expression: import("./helpers/rules").RuleExpression | null;
+    always_recommend: boolean;
     confirm: string;
     shortcut: string[];
     explanation: string;
@@ -407,6 +431,7 @@ export declare const isCommand: (command?: ICommandType | any) => command is {
     } & {
         position?: "inline" | "popover" | undefined;
     }))[] | null;
+    next_steps: (string | number)[];
 };
 export declare const isResource: (option: any) => option is IResourceType;
 export declare const isContextArgument: (argument: IArgumentType) => argument is {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "commandbar",
-  "version": "1.6.13",
+  "version": "1.6.14",
   "description": "Javascript Utility for CommandBar",
   "main": "build/commandbar-js/src/index.js",
   "types": "build/commandbar-js/src/index.d.ts",