@becollective/utils 2.0.9 → 2.0.11

package/lib/constants/opportunities.d.ts

@@ -1,4 +1,73 @@
-declare const _default: {
+export declare const typesMap: {
+    roleFixed: string;
+    roleFlexible: string;
+    ongoing: string;
+};
+export declare const typesMapV2: {
+    shift: string;
+    flexible: string;
+};
+export declare const types: string[];
+export declare const typesV2: string[];
+export declare const statuses: string[];
+export declare const volunteer: {
+    shiftStatus: {
+        approved: string;
+        cancelled: string;
+        left: string;
+    };
+    ruleStatus: {
+        approved: string;
+        cancelled: string;
+    };
+    volunteerStatus: {
+        approved: string;
+        pending: string;
+        invited: string;
+        declined: string;
+        left: string;
+    };
+};
+export declare const checklist: {
+    key: string;
+    value: string;
+}[];
+export declare const defaultOptions: {
+    details: {
+        currentJobTitle: string;
+        dateOfBirth: string;
+        emergencyContactDetails: string;
+        gender: string;
+        homeAddress: string;
+        phoneNumber: string;
+    };
+    requirements: {
+        driversLicense: string;
+        firstAidCertificate: string;
+        orientation: string;
+        policeCheck: string;
+        training: string;
+        workingWithChildrenCheck: string;
+    };
+    suitability: {
+        families: string;
+        deafHardOfHearing: string;
+        intellectuallyDisabled: string;
+        largeGroups: string;
+        skilledVolunteers: string;
+        travellingShortTermVolunteers: string;
+        blindLowVision: string;
+        volunteersWithLimitedEnglish: string;
+        wheelchairUsers: string;
+        workingExperience: string;
+        employeeVolunteers: string;
+        socialPrescribing: string;
+        publicTransportUsers: string;
+        LGBTQIAPlusCommunity: string;
+        LongTermVolunteers: string;
+    };
+};
+export declare const opportunities: {
     types: string[];
     typesMap: {
         roleFixed: string;
@@ -69,4 +138,4 @@ declare const _default: {
         };
     };
 };
-export default _default;
+export default opportunities;

package/lib/constants/opportunities.js

@@ -1,11 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const typesMap = {
+exports.opportunities = exports.defaultOptions = exports.checklist = exports.volunteer = exports.statuses = exports.typesV2 = exports.types = exports.typesMapV2 = exports.typesMap = void 0;
+exports.typesMap = {
     roleFixed: 'role-fixed',
     roleFlexible: 'role-flexible',
     ongoing: 'ongoing',
 };
-const typesMapV2 = {
+exports.typesMapV2 = {
     shift: 'shift',
     flexible: 'flexible',
 };
@@ -25,58 +26,65 @@ const volunteerStatus = {
     declined: 'declined',
     left: 'left',
 };
-exports.default = {
-    types: Object.values(typesMap),
-    typesMap,
-    typesV2: Object.values(typesMapV2),
-    typesMapV2,
-    statuses: ['draft', 'pending', 'published', 'cancelled'],
-    volunteer: {
-        shiftStatus: shiftStatus,
-        ruleStatus: ruleStatus,
-        volunteerStatus: volunteerStatus,
+exports.types = Object.values(exports.typesMap);
+exports.typesV2 = Object.values(exports.typesMapV2);
+exports.statuses = ['draft', 'pending', 'published', 'cancelled'];
+exports.volunteer = {
+    shiftStatus: shiftStatus,
+    ruleStatus: ruleStatus,
+    volunteerStatus: volunteerStatus,
+};
+exports.checklist = [
+    { key: 'interview', value: 'Interview' },
+    { key: 'police-check', value: 'Police Check' },
+    { key: 'reference-check', value: 'Reference Check' },
+    { key: 'screening', value: 'Screening' },
+    { key: 'training', value: 'Training' },
+    { key: 'trial', value: 'Check' },
+];
+exports.defaultOptions = {
+    details: {
+        currentJobTitle: 'Current Job Title',
+        dateOfBirth: 'Date of Birth',
+        emergencyContactDetails: 'Emergency Contact Details',
+        gender: 'Gender',
+        homeAddress: 'Home Address',
+        phoneNumber: 'Phone Number',
+    },
+    requirements: {
+        driversLicense: 'Drivers License',
+        firstAidCertificate: 'First Aid Certificate',
+        orientation: 'Orientation',
+        policeCheck: 'Police Check',
+        training: 'Training',
+        workingWithChildrenCheck: 'Working with Children Check',
     },
-    checklist: [
-        { key: 'interview', value: 'Interview' },
-        { key: 'police-check', value: 'Police Check' },
-        { key: 'reference-check', value: 'Reference Check' },
-        { key: 'screening', value: 'Screening' },
-        { key: 'training', value: 'Training' },
-        { key: 'trial', value: 'Check' },
-    ],
-    defaultOptions: {
-        details: {
-            currentJobTitle: 'Current Job Title',
-            dateOfBirth: 'Date of Birth',
-            emergencyContactDetails: 'Emergency Contact Details',
-            gender: 'Gender',
-            homeAddress: 'Home Address',
-            phoneNumber: 'Phone Number',
-        },
-        requirements: {
-            driversLicense: 'Drivers License',
-            firstAidCertificate: 'First Aid Certificate',
-            orientation: 'Orientation',
-            policeCheck: 'Police Check',
-            training: 'Training',
-            workingWithChildrenCheck: 'Working with Children Check',
-        },
-        suitability: {
-            families: 'Families',
-            deafHardOfHearing: 'Deaf/hard of hearing',
-            intellectuallyDisabled: 'Intellectual/learning disabilities',
-            largeGroups: 'Large groups (10+)',
-            skilledVolunteers: 'Skilled volunteers',
-            travellingShortTermVolunteers: 'Travelling/short term volunteers',
-            blindLowVision: 'Blind/low vision',
-            volunteersWithLimitedEnglish: 'Volunteers with limited English',
-            wheelchairUsers: 'Wheelchair users',
-            workingExperience: 'Work experience',
-            employeeVolunteers: 'Employee volunteers',
-            socialPrescribing: 'Social prescribing',
-            publicTransportUsers: 'Public transport users',
-            LGBTQIAPlusCommunity: 'LGBTQIA+ community',
-            LongTermVolunteers: 'Long term volunteers',
-        },
+    suitability: {
+        families: 'Families',
+        deafHardOfHearing: 'Deaf/hard of hearing',
+        intellectuallyDisabled: 'Intellectual/learning disabilities',
+        largeGroups: 'Large groups (10+)',
+        skilledVolunteers: 'Skilled volunteers',
+        travellingShortTermVolunteers: 'Travelling/short term volunteers',
+        blindLowVision: 'Blind/low vision',
+        volunteersWithLimitedEnglish: 'Volunteers with limited English',
+        wheelchairUsers: 'Wheelchair users',
+        workingExperience: 'Work experience',
+        employeeVolunteers: 'Employee volunteers',
+        socialPrescribing: 'Social prescribing',
+        publicTransportUsers: 'Public transport users',
+        LGBTQIAPlusCommunity: 'LGBTQIA+ community',
+        LongTermVolunteers: 'Long term volunteers',
     },
 };
+exports.opportunities = {
+    types: exports.types,
+    typesMap: exports.typesMap,
+    typesV2: exports.typesV2,
+    typesMapV2: exports.typesMapV2,
+    statuses: exports.statuses,
+    volunteer: exports.volunteer,
+    checklist: exports.checklist,
+    defaultOptions: exports.defaultOptions,
+};
+exports.default = exports.opportunities;

package/lib/forms.d.ts

@@ -1 +1,323 @@
-export {};
+type ValidateDataNameError = {
+    name: string;
+    key: string;
+    value: any;
+};
+type ValidateDataPropertyError = {
+    property: string;
+    message: string;
+    key: string;
+};
+export declare const validator: {
+    validateSchema: (schema: any, uischema: any) => Promise<boolean>;
+    validateSchemaPropertiesExist: (properties: any, keys: any, err: any) => (ValidateDataNameError | ValidateDataPropertyError)[] | null;
+    /**
+     * Check if every field in the form has a unique title
+     * @param {object} properties fields properties
+     * @param {string} err error name
+     */
+    validatePropertiesTitleUniqueness: (properties: any, err: any) => (ValidateDataNameError | ValidateDataPropertyError)[] | null;
+    /**
+     * Creates a new object from the input obj.
+     * All entries from the input whose values are empty arrays are missing in the new object
+     * @param {Object} data 1-depth obj
+     * @returns A new object without empty arrays
+     */
+    stripEmptyArraysFromData: (data: any) => {};
+    validateData: (schema: any, data: any) => Promise<void>;
+    getValidatorForType: (type: any) => any;
+    getValidatorForTypeData: (type: any) => any;
+    uiSchema: {
+        type: string;
+        required: string[];
+        properties: {
+            'ui:title': {
+                type: string;
+            };
+            'ui:helpertext': {
+                type: string;
+            };
+            'ui:bc-helpertext': {
+                type: string;
+            };
+            'ui:bc-required': {
+                type: string;
+            };
+            'ui:bc-multiSelect': {
+                type: string;
+            };
+            'ui:widget': {
+                type: string;
+                enum: string[];
+            };
+        };
+    };
+    schemaTypes: {
+        string: {
+            type: string;
+            required: string[];
+            properties: {
+                title: {
+                    type: string;
+                    minLength: number;
+                };
+            };
+        };
+        number: {
+            type: string;
+            required: string[];
+            properties: {
+                title: {
+                    type: string;
+                    minLength: number;
+                };
+            };
+        };
+        boolean: {
+            type: string;
+            required: string[];
+            properties: {
+                title: {
+                    type: string;
+                    minLength: number;
+                };
+            };
+        };
+        date: {
+            type: string;
+            required: string[];
+            properties: {
+                title: {
+                    type: string;
+                    minLength: number;
+                };
+                type: {
+                    const: string;
+                };
+            };
+        };
+        dateRange: {
+            type: string;
+            required: string[];
+            properties: {
+                title: {
+                    type: string;
+                    minLength: number;
+                };
+                type: {
+                    const: string;
+                };
+            };
+        };
+        phone: {
+            type: string;
+            required: string[];
+            properties: {
+                title: {
+                    type: string;
+                    minLength: number;
+                };
+                type: {
+                    const: string;
+                };
+            };
+        };
+        skills: {
+            type: string;
+            required: string[];
+            properties: {
+                title: {
+                    type: string;
+                    minLength: number;
+                };
+                uniqueItems: {
+                    type: string;
+                };
+                items: {
+                    type: string;
+                    properties: {
+                        anyOf: {
+                            type: string;
+                            minItems: number;
+                            items: {
+                                type: string;
+                                properties: {
+                                    type: {
+                                        type: string;
+                                    };
+                                    title: {
+                                        type: string;
+                                    };
+                                    enum: {
+                                        type: string;
+                                        minItems: number;
+                                        items: {
+                                            type: string;
+                                            minLength: number;
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            };
+        };
+        qualifications: {
+            type: string;
+            required: string[];
+            properties: {
+                title: {
+                    type: string;
+                    minLength: number;
+                };
+                uniqueItems: {
+                    type: string;
+                };
+                items: {
+                    type: string;
+                    properties: {
+                        type: {
+                            const: string;
+                        };
+                        enum: {
+                            type: string;
+                            minItems: number;
+                            items: {
+                                type: string;
+                            }[];
+                        };
+                    };
+                };
+            };
+        };
+        array: {
+            type: string;
+            required: string[];
+            properties: {
+                title: {
+                    type: string;
+                    minLength: number;
+                };
+                uniqueItems: {
+                    type: string;
+                };
+                items: {
+                    type: string;
+                    properties: {
+                        anyOf: {
+                            type: string;
+                            minItems: number;
+                            uniqueItems: boolean;
+                            items: {
+                                type: string;
+                                properties: {
+                                    type: {
+                                        type: string;
+                                    };
+                                    title: {
+                                        type: string;
+                                    };
+                                    enum: {
+                                        type: string;
+                                        minItems: number;
+                                        items: {
+                                            type: string;
+                                            minLength: number;
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            };
+        };
+        heading: {
+            type: string;
+            required: string[];
+            properties: {
+                title: {
+                    type: string;
+                    minLength: number;
+                };
+                type: {
+                    const: string;
+                };
+            };
+        };
+        spacer: {
+            type: string;
+            properties: {
+                type: {
+                    const: string;
+                };
+            };
+        };
+        location: {
+            type: string;
+            required: string[];
+            properties: {
+                title: {
+                    type: string;
+                    minLength: number;
+                };
+                type: {
+                    const: string;
+                };
+            };
+        };
+        file: {
+            type: string;
+            required: string[];
+            properties: {
+                title: {
+                    type: string;
+                    minLength: number;
+                };
+            };
+        };
+        textParagraph: {
+            type: string;
+            required: string[];
+            properties: {
+                text: {
+                    type: string;
+                    minLength: number;
+                };
+            };
+        };
+    };
+    dataTypeIsValid: {
+        string: (data: any, schema: any) => any;
+        boolean: (data: any) => boolean;
+        number: (data: any) => boolean;
+        date: (data: any) => boolean;
+        dateRange: (data: any) => boolean;
+        phone: (data: any) => any;
+        skills: (data: any, schema: any) => boolean;
+        qualifications: (data: any, schema: any) => boolean;
+        array: (data: any, schema: any) => boolean;
+        heading: () => boolean;
+        spacer: () => boolean;
+        location: (data: any) => boolean;
+        file: (data: any) => boolean;
+    };
+    dataTypes: {
+        string: (schema: any, data: any) => Promise<void>;
+        boolean: (schema: any, data: any) => Promise<void>;
+        date: (schema: any, data: any) => Promise<void>;
+        dateRange: (schema: any, data: any) => Promise<void>;
+        phone: (schema: any, data: any) => Promise<void>;
+        skills: (schema: any, data: any) => Promise<void>;
+        qualifications: (schema: any, data: any) => Promise<void>;
+        array: (schema: any, data: any) => Promise<void>;
+        heading: (schema: any, data: any) => Promise<void>;
+        spacer: (schema: any, data: any) => Promise<void>;
+        location: (schema: any, data: any) => Promise<void>;
+        file: (schema: any, data: any) => Promise<void>;
+        number: (schema: any, data: any) => Promise<void>;
+        textParagraph: (schema: any, data: any) => Promise<void>;
+    };
+};
+export default validator;

package/lib/forms.js

@@ -3,6 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.validator = void 0;
 /* eslint-disable no-prototype-builtins */
 const ajv_1 = __importDefault(require("ajv"));
 const ajv = new ajv_1.default({
@@ -60,14 +61,14 @@ const isValidYear = (value) => {
 };
 const validateType = async (params) => {
     const { type, data, schema, error } = params;
-    if (validator.dataTypeIsValid[type](data, schema)) {
+    if (exports.validator.dataTypeIsValid[type](data, schema)) {
         return;
     }
     throw {
         name: error || `Property is not a ${type}`
     };
 };
-const validator = {
+exports.validator = {
     validateSchema: async (schema, uischema) => {
         if (!schema.hasOwnProperty('properties')) {
             throw {
@@ -83,19 +84,19 @@ const validator = {
         let result;
         const errors = [];
         const keys = Object.keys(schema.properties);
-        result = validator.validateSchemaPropertiesExist(schema.required, keys, 'required-item-not-found');
+        result = exports.validator.validateSchemaPropertiesExist(schema.required, keys, 'required-item-not-found');
         if (result) {
             throw result;
         }
-        result = validator.validateSchemaPropertiesExist(uischema['ui:order'], keys, 'order-item-not-found');
+        result = exports.validator.validateSchemaPropertiesExist(uischema['ui:order'], keys, 'order-item-not-found');
         if (result) {
             throw result;
         }
-        result = validator.validateSchemaPropertiesExist(keys, Object.keys(uischema), 'ui-data-schema-mismatch');
+        result = exports.validator.validateSchemaPropertiesExist(keys, Object.keys(uischema), 'ui-data-schema-mismatch');
         if (result) {
             throw result;
         }
-        result = validator.validatePropertiesTitleUniqueness(schema.properties, 'Titles must be unique.');
+        result = exports.validator.validatePropertiesTitleUniqueness(schema.properties, 'Titles must be unique.');
         if (result) {
             throw result;
         }
@@ -115,7 +116,7 @@ const validator = {
                 bcRequired: false
               }
             */
-            const f = validator.getValidatorForType(o.bcType || o.type);
+            const f = exports.validator.getValidatorForType(o.bcType || o.type);
             if (o.hasOwnProperty('bcReportable')) {
                 if (!BC_REPORTABLE_FIELDS[o.bcReportable] && !o.bcReportable.startsWith('USER_')) {
                     errors.push({
@@ -155,7 +156,7 @@ const validator = {
                 return;
             }
             const data = uischema[o];
-            const valid = ajv.validate(validator.uiSchema, data);
+            const valid = ajv.validate(exports.validator.uiSchema, data);
             if (valid !== true) {
                 errors.push({ name: 'invalid-uischema-property', object: o });
             }
@@ -268,7 +269,7 @@ const validator = {
             // value is the data the user submits for the above property
             // eg. +61434111222
             try {
-                const v = validator.getValidatorForTypeData(property.bcType || property.type);
+                const v = exports.validator.getValidatorForTypeData(property.bcType || property.type);
                 await v(property, value);
             }
             catch (e) {
@@ -281,10 +282,10 @@ const validator = {
         return;
     },
     getValidatorForType: (type) => {
-        return validator.schemaTypes[type] || null;
+        return exports.validator.schemaTypes[type] || null;
     },
     getValidatorForTypeData: (type) => {
-        const v = validator.dataTypes[type];
+        const v = exports.validator.dataTypes[type];
         if (v) {
             return v;
         }
@@ -564,8 +565,8 @@ const validator = {
             return typeof data === 'string' && new Date(data).toString() !== 'Invalid Date' && isValidYear(data);
         },
         dateRange: (data) => {
-            const fromIsValid = validator.dataTypeIsValid.date(data.from);
-            const toIsValid = validator.dataTypeIsValid.date(data.to);
+            const fromIsValid = exports.validator.dataTypeIsValid.date(data.from);
+            const toIsValid = exports.validator.dataTypeIsValid.date(data.to);
             const toDateIsAFterFromDate = new Date(data.from) <= new Date(data.to);
             return fromIsValid && toIsValid && toDateIsAFterFromDate;
         },
@@ -725,4 +726,4 @@ const validator = {
         textParagraph: (schema, data) => validateType({ type: 'string', data, schema }),
     },
 };
-module.exports = validator;
+exports.default = exports.validator;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@becollective/utils",
-  "version": "2.0.9",
+  "version": "2.0.11",
   "description": "Common utilities",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",

package/src/constants/opportunities.ts

@@ -1,9 +1,9 @@
-const typesMap = {
+export const typesMap = {
   roleFixed: 'role-fixed',
   roleFlexible: 'role-flexible',
   ongoing: 'ongoing',
 };
-const typesMapV2 = {
+export const typesMapV2 = {
   shift: 'shift',
   flexible: 'flexible',
 };
@@ -27,58 +27,69 @@ const volunteerStatus = {
   left: 'left',
 };
 
-export default {
-  types: Object.values(typesMap),
-  typesMap,
-  typesV2: Object.values(typesMapV2),
-  typesMapV2,
-  statuses: ['draft', 'pending', 'published', 'cancelled'],
-  volunteer: {
-    shiftStatus: shiftStatus,
-    ruleStatus: ruleStatus,
-    volunteerStatus: volunteerStatus,
+export const types = Object.values(typesMap);
+export const typesV2 = Object.values(typesMapV2);
+export const statuses = ['draft', 'pending', 'published', 'cancelled'];
+export const volunteer = {
+  shiftStatus: shiftStatus,
+  ruleStatus: ruleStatus,
+  volunteerStatus: volunteerStatus,
+};
+
+export const checklist = [
+  { key: 'interview', value: 'Interview' },
+  { key: 'police-check', value: 'Police Check' },
+  { key: 'reference-check', value: 'Reference Check' },
+  { key: 'screening', value: 'Screening' },
+  { key: 'training', value: 'Training' },
+  { key: 'trial', value: 'Check' },
+];
+
+export const defaultOptions = {
+  details: {
+    currentJobTitle: 'Current Job Title',
+    dateOfBirth: 'Date of Birth',
+    emergencyContactDetails: 'Emergency Contact Details',
+    gender: 'Gender',
+    homeAddress: 'Home Address',
+    phoneNumber: 'Phone Number',
+  },
+  requirements: {
+    driversLicense: 'Drivers License',
+    firstAidCertificate: 'First Aid Certificate',
+    orientation: 'Orientation',
+    policeCheck: 'Police Check',
+    training: 'Training',
+    workingWithChildrenCheck: 'Working with Children Check',
   },
-  checklist: [
-    { key: 'interview', value: 'Interview' },
-    { key: 'police-check', value: 'Police Check' },
-    { key: 'reference-check', value: 'Reference Check' },
-    { key: 'screening', value: 'Screening' },
-    { key: 'training', value: 'Training' },
-    { key: 'trial', value: 'Check' },
-  ],
-  defaultOptions: {
-    details: {
-      currentJobTitle: 'Current Job Title',
-      dateOfBirth: 'Date of Birth',
-      emergencyContactDetails: 'Emergency Contact Details',
-      gender: 'Gender',
-      homeAddress: 'Home Address',
-      phoneNumber: 'Phone Number',
-    },
-    requirements: {
-      driversLicense: 'Drivers License',
-      firstAidCertificate: 'First Aid Certificate',
-      orientation: 'Orientation',
-      policeCheck: 'Police Check',
-      training: 'Training',
-      workingWithChildrenCheck: 'Working with Children Check',
-    },
-    suitability: {
-      families: 'Families',
-      deafHardOfHearing: 'Deaf/hard of hearing',
-      intellectuallyDisabled: 'Intellectual/learning disabilities',
-      largeGroups: 'Large groups (10+)',
-      skilledVolunteers: 'Skilled volunteers',
-      travellingShortTermVolunteers: 'Travelling/short term volunteers',
-      blindLowVision: 'Blind/low vision',
-      volunteersWithLimitedEnglish: 'Volunteers with limited English',
-      wheelchairUsers: 'Wheelchair users',
-      workingExperience: 'Work experience',
-      employeeVolunteers: 'Employee volunteers',
-      socialPrescribing: 'Social prescribing',
-      publicTransportUsers: 'Public transport users',
-      LGBTQIAPlusCommunity: 'LGBTQIA+ community',
-      LongTermVolunteers: 'Long term volunteers',
-    },
+  suitability: {
+    families: 'Families',
+    deafHardOfHearing: 'Deaf/hard of hearing',
+    intellectuallyDisabled: 'Intellectual/learning disabilities',
+    largeGroups: 'Large groups (10+)',
+    skilledVolunteers: 'Skilled volunteers',
+    travellingShortTermVolunteers: 'Travelling/short term volunteers',
+    blindLowVision: 'Blind/low vision',
+    volunteersWithLimitedEnglish: 'Volunteers with limited English',
+    wheelchairUsers: 'Wheelchair users',
+    workingExperience: 'Work experience',
+    employeeVolunteers: 'Employee volunteers',
+    socialPrescribing: 'Social prescribing',
+    publicTransportUsers: 'Public transport users',
+    LGBTQIAPlusCommunity: 'LGBTQIA+ community',
+    LongTermVolunteers: 'Long term volunteers',
   },
 };
+
+export const opportunities = {
+  types,
+  typesMap,
+  typesV2,
+  typesMapV2,
+  statuses,
+  volunteer,
+  checklist,
+  defaultOptions,
+};
+
+export default opportunities;

package/src/forms.ts

@@ -81,7 +81,7 @@ const validateType = async (params: { type: string, data: any, schema?: any, err
   };
 };
 
-const validator = {
+export const validator = {
   validateSchema: async (schema, uischema) => {
     if (!schema.hasOwnProperty('properties')) {
       throw {
@@ -804,4 +804,4 @@ const validator = {
   },
 };
 
-module.exports = validator;
+export default validator;