cozy-client 60.13.0 → 60.14.0

package/dist/CozyClient.js

@@ -3126,7 +3126,7 @@ var CozyClient = /*#__PURE__*/function () {
 CozyClient.hooks = CozyClient.hooks || {};
 CozyClient.fetchPolicies = _policies.default; //COZY_CLIENT_VERSION_PACKAGE in replaced by babel. See babel config
 
-CozyClient.version = "60.13.0";
+CozyClient.version = "60.14.0";
 
 _microee.default.mixin(CozyClient);
 

package/dist/models/applications.js

@@ -5,10 +5,12 @@ var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefau
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.sortApplicationsList = exports.getAppDisplayName = exports.getUrl = exports.isInstalled = exports.getStoreInstallationURL = exports.getStoreURL = void 0;
+exports.filterEntrypoints = exports.selectEntrypoints = exports.shouldDisplayEntrypoint = exports.checkEntrypointCondition = exports.sortApplicationsList = exports.getAppDisplayName = exports.getUrl = exports.isInstalled = exports.getStoreInstallationURL = exports.getStoreURL = void 0;
 
 var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
 
+var _cozyFlags = _interopRequireDefault(require("cozy-flags"));
+
 var _get = _interopRequireDefault(require("lodash/get"));
 
 var STORE_SLUG = 'store';
@@ -129,5 +131,93 @@ var sortApplicationsList = function sortApplicationsList(apps, slugsOrder) {
     return indexA - indexB;
   });
 };
+/**
+ * @typedef {Object} EntrypointTitle
+ * @property {string} [en] - English title
+ * @property {string} [fr] - French title
+ * @property {string} [ru] - Russian title
+ * @property {string} [vi] - Vietnamese title
+ */
+
+/**
+ * @typedef {Object} EntrypointCondition
+ * @property {'flag'} type - The type of condition (currently only 'flag' is supported)
+ * @property {string} name - The name of the flag
+ * @property {boolean} value - The expected value of the flag
+ */
+
+/**
+ * @typedef {Object} Entrypoint
+ * @property {string} name - The unique name of the entrypoint
+ * @property {EntrypointTitle} title - Localized titles for the entrypoint
+ * @property {string} hash - The URL hash for navigation
+ * @property {string} icon - Base64 encoded SVG icon
+ * @property {EntrypointCondition[]} [conditions] - Conditions that must be met to display the entrypoint
+ */
+
+/**
+ * Checks if an entrypoint condition is satisfied
+ *
+ * @param {EntrypointCondition} entrypointCondition - The condition to check
+ * @returns {boolean} True if the condition is satisfied
+ */
+
+
+exports.sortApplicationsList = sortApplicationsList;
+
+var checkEntrypointCondition = function checkEntrypointCondition(entrypointCondition) {
+  if (entrypointCondition.type === 'flag') {
+    return (0, _cozyFlags.default)(entrypointCondition.name) === entrypointCondition.value;
+  }
+
+  return false;
+};
+/**
+ * Checks if an entrypoint should be displayed based on its conditions
+ *
+ * @param {Entrypoint} entrypoint - The entrypoint to check
+ * @returns {boolean} True if all conditions are satisfied
+ */
+
+
+exports.checkEntrypointCondition = checkEntrypointCondition;
+
+var shouldDisplayEntrypoint = function shouldDisplayEntrypoint(entrypoint) {
+  var conditions = entrypoint.conditions || [];
+  return conditions.every(function (condition) {
+    return checkEntrypointCondition(condition);
+  });
+};
+/**
+ * Selects entrypoints by their names
+ *
+ * @param {Entrypoint[]} entrypoints - Array of entrypoints
+ * @param {string[]} names - Array of entrypoint names to select
+ * @returns {Entrypoint[]} Filtered array of entrypoints
+ */
+
+
+exports.shouldDisplayEntrypoint = shouldDisplayEntrypoint;
+
+var selectEntrypoints = function selectEntrypoints(entrypoints, names) {
+  return entrypoints.filter(function (entrypoint) {
+    return names.includes(entrypoint.name);
+  });
+};
+/**
+ * Filters entrypoints based on whether they should be displayed
+ *
+ * @param {Entrypoint[]} entrypoints - Array of entrypoints
+ * @returns {Entrypoint[]} Filtered array of entrypoints that should be displayed
+ */
+
+
+exports.selectEntrypoints = selectEntrypoints;
+
+var filterEntrypoints = function filterEntrypoints(entrypoints) {
+  return entrypoints.filter(function (entrypoint) {
+    return shouldDisplayEntrypoint(entrypoint);
+  });
+};
 
-exports.sortApplicationsList = sortApplicationsList;
+exports.filterEntrypoints = filterEntrypoints;

package/dist/models/applications.spec.js

@@ -1,11 +1,18 @@
+import flag from 'cozy-flags'
 import { applications } from './'
 const {
   getAppDisplayName,
   getStoreURL,
   getStoreInstallationURL,
-  sortApplicationsList
+  sortApplicationsList,
+  checkEntrypointCondition,
+  shouldDisplayEntrypoint,
+  selectEntrypoints,
+  filterEntrypoints
 } = applications
 
+jest.mock('cozy-flags')
+
 describe('applications model', () => {
   describe('application name', () => {
     it('should return names', () => {
@@ -224,4 +231,241 @@ describe('applications model', () => {
       expect(result).toEqual(expected)
     })
   })
+
+  describe('entrypoints', () => {
+    beforeEach(() => {
+      flag.mockReset()
+    })
+
+    describe('checkEntrypointCondition', () => {
+      it('should return true when flag condition is met', () => {
+        flag.mockReturnValue(true)
+        /** @type {import('./applications').EntrypointCondition} */
+        const condition = {
+          type: 'flag',
+          name: 'drive.office.enabled',
+          value: true
+        }
+        expect(checkEntrypointCondition(condition)).toBe(true)
+      })
+
+      it('should return false when flag condition is not met', () => {
+        flag.mockReturnValue(false)
+        /** @type {import('./applications').EntrypointCondition} */
+        const condition = {
+          type: 'flag',
+          name: 'drive.office.enabled',
+          value: true
+        }
+        expect(checkEntrypointCondition(condition)).toBe(false)
+      })
+
+      it('should return false for unknown condition types', () => {
+        const condition = {
+          type: 'unknown',
+          name: 'some.flag',
+          value: true
+        }
+        // @ts-expect-error Testing a bad format on purpose
+        expect(checkEntrypointCondition(condition)).toBe(false)
+      })
+    })
+
+    describe('shouldDisplayEntrypoint', () => {
+      it('should return true when entrypoint has no conditions', () => {
+        /** @type {import('./applications').Entrypoint} */
+        const entrypoint = {
+          name: 'test-entrypoint',
+          title: { en: 'Test' },
+          hash: '/test',
+          icon: 'test-icon'
+        }
+        expect(shouldDisplayEntrypoint(entrypoint)).toBe(true)
+      })
+
+      it('should return true when all conditions are met', () => {
+        flag.mockReturnValue(true)
+        /** @type {import('./applications').Entrypoint} */
+        const entrypoint = {
+          name: 'test-entrypoint',
+          title: { en: 'Test' },
+          hash: '/test',
+          icon: 'test-icon',
+          conditions: [
+            { type: 'flag', name: 'drive.office.enabled', value: true }
+          ]
+        }
+        expect(shouldDisplayEntrypoint(entrypoint)).toBe(true)
+      })
+
+      it('should return false when at least one condition is not met', () => {
+        flag.mockImplementation((/** @type {string} */ name) => {
+          if (name === 'drive.office.enabled') return true
+          if (name === 'other.flag') return false
+          return false
+        })
+        /** @type {import('./applications').Entrypoint} */
+        const entrypoint = {
+          name: 'test-entrypoint',
+          title: { en: 'Test' },
+          hash: '/test',
+          icon: 'test-icon',
+          conditions: [
+            { type: 'flag', name: 'drive.office.enabled', value: true },
+            { type: 'flag', name: 'other.flag', value: true }
+          ]
+        }
+        expect(shouldDisplayEntrypoint(entrypoint)).toBe(false)
+      })
+
+      it('should return true when conditions array is empty', () => {
+        /** @type {import('./applications').Entrypoint} */
+        const entrypoint = {
+          name: 'test-entrypoint',
+          title: { en: 'Test' },
+          hash: '/test',
+          icon: 'test-icon',
+          conditions: []
+        }
+        expect(shouldDisplayEntrypoint(entrypoint)).toBe(true)
+      })
+    })
+
+    describe('selectEntrypoints', () => {
+      const entrypoints = [
+        {
+          name: 'new-file-type-text',
+          title: { en: 'Doc' },
+          hash: '/onlyoffice/create/text',
+          icon: 'icon-text'
+        },
+        {
+          name: 'new-file-type-spreadsheet',
+          title: { en: 'Spreadsheet' },
+          hash: '/onlyoffice/create/spreadsheet',
+          icon: 'icon-spreadsheet'
+        },
+        {
+          name: 'new-file-type-presentation',
+          title: { en: 'Presentation' },
+          hash: '/onlyoffice/create/presentation',
+          icon: 'icon-presentation'
+        }
+      ]
+
+      it('should return entrypoints matching the given names', () => {
+        const names = ['new-file-type-text', 'new-file-type-presentation']
+        const result = selectEntrypoints(entrypoints, names)
+        expect(result).toHaveLength(2)
+        expect(result[0].name).toBe('new-file-type-text')
+        expect(result[1].name).toBe('new-file-type-presentation')
+      })
+
+      it('should return empty array when no names match', () => {
+        const names = ['non-existent']
+        const result = selectEntrypoints(entrypoints, names)
+        expect(result).toEqual([])
+      })
+
+      it('should return all entrypoints when all names are provided', () => {
+        const names = [
+          'new-file-type-text',
+          'new-file-type-spreadsheet',
+          'new-file-type-presentation'
+        ]
+        const result = selectEntrypoints(entrypoints, names)
+        expect(result).toHaveLength(3)
+      })
+
+      it('should return empty array when names array is empty', () => {
+        const result = selectEntrypoints(entrypoints, [])
+        expect(result).toEqual([])
+      })
+    })
+
+    describe('filterEntrypoints', () => {
+      it('should return only entrypoints that should be displayed', () => {
+        flag.mockImplementation((/** @type {string} */ name) => {
+          if (name === 'feature.1') return true
+          if (name === 'feature.2') return false
+          return false
+        })
+
+        /** @type {import('./applications').Entrypoint[]} */
+        const entrypoints = [
+          {
+            name: 'always-visible',
+            title: { en: 'Always' },
+            hash: '/always',
+            icon: 'icon'
+          },
+          {
+            name: 'feature-1',
+            title: { en: 'Feature 1' },
+            hash: '/feature1',
+            icon: 'icon',
+            conditions: [{ type: 'flag', name: 'feature.1', value: true }]
+          },
+          {
+            name: 'feature-2',
+            title: { en: 'Feature 2' },
+            hash: '/feature2',
+            icon: 'icon',
+            conditions: [{ type: 'flag', name: 'feature.2', value: true }]
+          }
+        ]
+
+        const result = filterEntrypoints(entrypoints)
+        expect(result).toHaveLength(2)
+        expect(result[0].name).toBe('always-visible')
+        expect(result[1].name).toBe('feature-1')
+      })
+
+      it('should return all entrypoints when all conditions are met', () => {
+        flag.mockReturnValue(true)
+        /** @type {import('./applications').Entrypoint[]} */
+        const entrypoints = [
+          {
+            name: 'feature-1',
+            title: { en: 'Feature 1' },
+            hash: '/feature1',
+            icon: 'icon',
+            conditions: [{ type: 'flag', name: 'feature.1', value: true }]
+          },
+          {
+            name: 'feature-2',
+            title: { en: 'Feature 2' },
+            hash: '/feature2',
+            icon: 'icon',
+            conditions: [{ type: 'flag', name: 'feature.2', value: true }]
+          }
+        ]
+
+        const result = filterEntrypoints(entrypoints)
+        expect(result).toHaveLength(2)
+      })
+
+      it('should return empty array when no entrypoints should be displayed', () => {
+        flag.mockReturnValue(false)
+        /** @type {import('./applications').Entrypoint[]} */
+        const entrypoints = [
+          {
+            name: 'feature-1',
+            title: { en: 'Feature 1' },
+            hash: '/feature1',
+            icon: 'icon',
+            conditions: [{ type: 'flag', name: 'feature.1', value: true }]
+          }
+        ]
+
+        const result = filterEntrypoints(entrypoints)
+        expect(result).toEqual([])
+      })
+
+      it('should handle empty entrypoints array', () => {
+        const result = filterEntrypoints([])
+        expect(result).toEqual([])
+      })
+    })
+  })
 })

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cozy-client",
-  "version": "60.13.0",
+  "version": "60.14.0",
   "license": "MIT",
   "main": "dist/index.node.js",
   "browser": "dist/index.js",
@@ -74,5 +74,5 @@
     "react-native-ios11-devicecheck": "^0.0.3"
   },
   "sideEffects": false,
-  "gitHead": "4f2002995a7e321591cbf56b4d4235cd062457ce"
+  "gitHead": "5147a1819dbf195aa920b5aea20265573e1b81bb"
 }

package/types/models/applications.d.ts

@@ -4,3 +4,61 @@ export function isInstalled(apps?: any[], wantedApp?: object): object;
 export function getUrl(app: object): string;
 export function getAppDisplayName(app: object, lang: string): string;
 export function sortApplicationsList(apps: object[], slugsOrder: string[]): object[];
+export function checkEntrypointCondition(entrypointCondition: EntrypointCondition): boolean;
+export function shouldDisplayEntrypoint(entrypoint: Entrypoint): boolean;
+export function selectEntrypoints(entrypoints: Entrypoint[], names: string[]): Entrypoint[];
+export function filterEntrypoints(entrypoints: Entrypoint[]): Entrypoint[];
+export type EntrypointTitle = {
+    /**
+     * - English title
+     */
+    en?: string;
+    /**
+     * - French title
+     */
+    fr?: string;
+    /**
+     * - Russian title
+     */
+    ru?: string;
+    /**
+     * - Vietnamese title
+     */
+    vi?: string;
+};
+export type EntrypointCondition = {
+    /**
+     * - The type of condition (currently only 'flag' is supported)
+     */
+    type: 'flag';
+    /**
+     * - The name of the flag
+     */
+    name: string;
+    /**
+     * - The expected value of the flag
+     */
+    value: boolean;
+};
+export type Entrypoint = {
+    /**
+     * - The unique name of the entrypoint
+     */
+    name: string;
+    /**
+     * - Localized titles for the entrypoint
+     */
+    title: EntrypointTitle;
+    /**
+     * - The URL hash for navigation
+     */
+    hash: string;
+    /**
+     * - Base64 encoded SVG icon
+     */
+    icon: string;
+    /**
+     * - Conditions that must be met to display the entrypoint
+     */
+    conditions?: EntrypointCondition[];
+};