packages/sieve/src/interface.ts

   1 import type { ConditionComparator, FilterStatement } from '@proton/components/containers/filters/interfaces';
   2
   3 export type SIEVE_VERSION = 1 | 2;
   4
   5 export interface ValueTypePair {
   6     Type: string;
   7     Value: string;
   8 }
   9 export interface ValueNamePair {
  10     Name: string;
  11     Value: string;
  12 }
  13 export interface ValueTextPair {
  14     Text: string;
  15     Value: string;
  16 }
  17
  18 export interface PrepareType {
  19     Type: string;
  20     Headers: string;
  21 }
  22
  23 export interface Match {
  24     Type: string;
  25 }
  26
  27 export const LABEL_KEYS = {
  28     all: 'All',
  29     any: 'Any',
  30     subject: 'Subject',
  31     sender: 'Sender',
  32     recipient: 'Recipient',
  33     attachments: 'Attachments',
  34     contains: 'contains',
  35     '!contains': 'does not contain',
  36     is: 'is exactly',
  37     '!is': 'is not',
  38     matches: 'matches',
  39     '!matches': 'does not match',
  40     starts: 'begins with',
  41     '!starts': 'does not begin with',
  42     ends: 'ends with',
  43     '!ends': 'does not end with',
  44 };
  45
  46 export type LABEL_KEY_TYPE = keyof typeof LABEL_KEYS;
  47
  48 export const LABEL_KEY_MATCHING = [
  49     {
  50         match: 'Contains',
  51         default: 'contains',
  52         negate: '!contains',
  53     },
  54     {
  55         match: 'Is',
  56         default: 'is',
  57         negate: '!is',
  58     },
  59     {
  60         match: 'Matches',
  61         default: 'matches',
  62         negate: '!matches',
  63     },
  64     {
  65         match: 'Starts',
  66         default: 'starts',
  67         negate: '!starts',
  68     },
  69     { match: 'Ends', default: 'ends', negate: '!ends' },
  70 ];
  71
  72 export const MATCH_KEYS: Partial<Record<ConditionComparator | 'default', string>> = {
  73     is: 'Is',
  74     contains: 'Contains',
  75     matches: 'Matches',
  76     starts: 'Starts',
  77     ends: 'Ends',
  78     default: 'Defaults',
  79 };
  80
  81 export const OPERATOR_KEYS: Record<FilterStatement, string> = {
  82     all: 'AllOf',
  83     any: 'AnyOf',
  84 };
  85
  86 export interface BuildFileIntoType {
  87     Type: string;
  88     Name: string | ValueTypePair;
  89 }
  90
  91 export interface IfTest {
  92     Headers: string[];
  93     Keys: string[];
  94     Match: Match;
  95     Format: Match;
  96     Type: string;
  97     Test: IfTest;
  98     DateFormat?: string;
  99     Zone?: {
 100         Argument: string;
 101         Type: string;
 102     };
 103     MatchOperator?: {
 104         Comparator: string;
 105         Type: string;
 106     };
 107     AddressPart?: Match;
 108 }
 109
 110 export interface ItType {
 111     If: {
 112         Tests: IfTest[];
 113         Type: string;
 114     };
 115     Then: {
 116         Type: string;
 117         Name: string;
 118         Flags: string[];
 119         Message: string;
 120         Args: any[];
 121     }[];
 122     Type: string;
 123 }
 124
 125 export interface SieveTests {
 126     Headers?: string[];
 127     Test?: {};
 128     Type: string;
 129 }
 130
 131 export interface SieveCondition {
 132     tests: SieveTests[];
 133     comparators: string[];
 134     dollarNeeded: boolean;
 135 }
 136
 137 export type EscapeVariableType = string | ValueTypePair;
 138
 139 export interface MainNodeType {
 140     List?: string[];
 141     Type?: string;
 142     Name?: string;
 143     Value?: string;
 144     Flags?: never[];
 145     Text?: string;
 146     Then?: any[];
 147     If?: {
 148         Tests: any;
 149         Type: string;
 150     };
 151 }
 152
 153 export type SieveBranch =
 154     | {
 155           List: string[];
 156           Type: string;
 157       }
 158     | {
 159           Name: string;
 160           Value: string;
 161           Flags: never[];
 162           Type: string;
 163       }
 164     | {
 165           Text: string;
 166           Type: string;
 167       }
 168     | ItType;