@nocobase/plugin-workflow 0.11.1-alpha.5 → 0.12.0-alpha.2

package/lib/client/variable.js

@@ -1,319 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.defaultFieldNames = exports.BaseTypeSets = void 0;
-exports.getCollectionFieldOptions = getCollectionFieldOptions;
-exports.triggerOptions = exports.systemOptions = exports.scopeOptions = exports.nodesOptions = void 0;
-exports.useWorkflowVariableOptions = useWorkflowVariableOptions;
-function _client() {
-  const data = require("@nocobase/client");
-  _client = function _client() {
-    return data;
-  };
-  return data;
-}
-var _FlowContext = require("./FlowContext");
-var _locale = require("./locale");
-var _nodes = require("./nodes");
-var _triggers = require("./triggers");
-function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
-function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
-function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
-function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
-function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
-function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); }
-function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
-const defaultFieldNames = {
-  label: 'label',
-  value: 'value',
-  children: 'children'
-};
-exports.defaultFieldNames = defaultFieldNames;
-const nodesOptions = {
-  label: `{{t("Node result", { ns: "${_locale.NAMESPACE}" })}}`,
-  value: '$jobsMapByNodeId',
-  useOptions(options) {
-    const current = (0, _nodes.useNodeContext)();
-    const upstreams = (0, _nodes.useAvailableUpstreams)(current);
-    const result = [];
-    upstreams.forEach(node => {
-      var _instruction$useVaria;
-      const instruction = _nodes.instructions.get(node.type);
-      const subOption = (_instruction$useVaria = instruction.useVariables) === null || _instruction$useVaria === void 0 ? void 0 : _instruction$useVaria.call(instruction, node, options);
-      if (subOption) {
-        result.push(subOption);
-      }
-    });
-    return result;
-  }
-};
-exports.nodesOptions = nodesOptions;
-const triggerOptions = {
-  label: `{{t("Trigger variables", { ns: "${_locale.NAMESPACE}" })}}`,
-  value: '$context',
-  useOptions(options) {
-    var _trigger$useVariables, _trigger$useVariables2;
-    const _useFlowContext = (0, _FlowContext.useFlowContext)(),
-      workflow = _useFlowContext.workflow;
-    const trigger = _triggers.triggers.get(workflow.type);
-    return (_trigger$useVariables = trigger === null || trigger === void 0 ? void 0 : (_trigger$useVariables2 = trigger.useVariables) === null || _trigger$useVariables2 === void 0 ? void 0 : _trigger$useVariables2.call(trigger, workflow.config, options)) !== null && _trigger$useVariables !== void 0 ? _trigger$useVariables : null;
-  }
-};
-exports.triggerOptions = triggerOptions;
-const scopeOptions = {
-  label: `{{t("Scope variables", { ns: "${_locale.NAMESPACE}" })}}`,
-  value: '$scopes',
-  useOptions(options) {
-    const _options$fieldNames = options.fieldNames,
-      fieldNames = _options$fieldNames === void 0 ? defaultFieldNames : _options$fieldNames;
-    const current = (0, _nodes.useNodeContext)();
-    const scopes = (0, _nodes.useUpstreamScopes)(current);
-    const result = [];
-    scopes.forEach(node => {
-      var _instruction$useScope;
-      const instruction = _nodes.instructions.get(node.type);
-      const subOptions = (_instruction$useScope = instruction.useScopeVariables) === null || _instruction$useScope === void 0 ? void 0 : _instruction$useScope.call(instruction, node, options);
-      if (subOptions) {
-        var _node$title;
-        result.push({
-          key: node.id.toString(),
-          [fieldNames.value]: node.id.toString(),
-          [fieldNames.label]: (_node$title = node.title) !== null && _node$title !== void 0 ? _node$title : `#${node.id}`,
-          [fieldNames.children]: subOptions
-        });
-      }
-    });
-    return result;
-  }
-};
-exports.scopeOptions = scopeOptions;
-const systemOptions = {
-  label: `{{t("System variables", { ns: "${_locale.NAMESPACE}" })}}`,
-  value: '$system',
-  useOptions({
-    types,
-    fieldNames = defaultFieldNames
-  }) {
-    return [...(!types || types.includes('date') ? [{
-      key: 'now',
-      [fieldNames.label]: (0, _locale.lang)('System time'),
-      [fieldNames.value]: 'now'
-    }] : [])];
-  }
-};
-exports.systemOptions = systemOptions;
-const BaseTypeSets = {
-  boolean: new Set(['checkbox']),
-  number: new Set(['integer', 'number', 'percent']),
-  string: new Set(['input', 'password', 'email', 'phone', 'select', 'radioGroup', 'text', 'markdown', 'richText', 'expression', 'time']),
-  date: new Set(['date', 'createdAt', 'updatedAt'])
-};
-// { type: 'reference', options: { collection: 'users', multiple: false } }
-// { type: 'reference', options: { collection: 'attachments', multiple: false } }
-// { type: 'reference', options: { collection: 'myExpressions', entity: false } }
-exports.BaseTypeSets = BaseTypeSets;
-function matchFieldType(field, type, appends) {
-  const inputType = typeof type;
-  if (inputType === 'string') {
-    var _BaseTypeSets$type;
-    return (_BaseTypeSets$type = BaseTypeSets[type]) === null || _BaseTypeSets$type === void 0 ? void 0 : _BaseTypeSets$type.has(field.interface);
-  }
-  if (inputType === 'object' && type.type === 'reference') {
-    if (isAssociationField(field)) {
-      var _type$options, _type$options2, _type$options3;
-      return ((_type$options = type.options) === null || _type$options === void 0 ? void 0 : _type$options.entity) && (field.collectionName === ((_type$options2 = type.options) === null || _type$options2 === void 0 ? void 0 : _type$options2.collection) || ((_type$options3 = type.options) === null || _type$options3 === void 0 ? void 0 : _type$options3.collection) === '*');
-    } else if (field.isForeignKey) {
-      var _type$options4, _type$options5;
-      return field.collectionName === ((_type$options4 = type.options) === null || _type$options4 === void 0 ? void 0 : _type$options4.collection) && field.name === 'id' || field.target === ((_type$options5 = type.options) === null || _type$options5 === void 0 ? void 0 : _type$options5.collection);
-    } else {
-      return false;
-    }
-  }
-  if (inputType === 'function') {
-    return type(field, appends);
-  }
-  return false;
-}
-function isAssociationField(field) {
-  return ['belongsTo', 'hasOne', 'hasMany', 'belongsToMany'].includes(field.type);
-}
-function getNextAppends(field, appends) {
-  const fieldPrefix = `${field.name}.`;
-  return appends.filter(item => item.startsWith(fieldPrefix)).map(item => item.replace(fieldPrefix, ''));
-}
-function filterTypedFields({
-  fields,
-  types,
-  appends,
-  compile,
-  getCollectionFields
-}) {
-  return fields.filter(field => {
-    const match = types !== null && types !== void 0 && types.length ? types.some(type => matchFieldType(field, type, appends)) : true;
-    if (isAssociationField(field)) {
-      const nextAppends = getNextAppends(field, appends);
-      const included = appends.includes(field.name);
-      if (match) {
-        return included;
-      } else {
-        return (nextAppends.length || included) && filterTypedFields({
-          fields: getNormalizedFields(field.target, {
-            compile,
-            getCollectionFields
-          }),
-          types,
-          // depth: depth - 1,
-          appends: nextAppends,
-          compile,
-          getCollectionFields
-        }).length;
-      }
-    } else {
-      return match;
-    }
-  });
-}
-function useWorkflowVariableOptions(options = {}) {
-  var _options$fieldNames2;
-  const fieldNames = Object.assign({}, defaultFieldNames, (_options$fieldNames2 = options.fieldNames) !== null && _options$fieldNames2 !== void 0 ? _options$fieldNames2 : {});
-  const opts = Object.assign(options, {
-    fieldNames
-  });
-  const compile = (0, _client().useCompile)();
-  const result = [scopeOptions, nodesOptions, triggerOptions, systemOptions].map(item => {
-    const children = item.useOptions(opts).filter(Boolean);
-    return {
-      [fieldNames.label]: compile(item.label),
-      [fieldNames.value]: item.value,
-      key: item[fieldNames.value],
-      [fieldNames.children]: children,
-      disabled: children && !children.length
-    };
-  });
-  return result;
-}
-function getNormalizedFields(collectionName, {
-  compile,
-  getCollectionFields
-}) {
-  const fields = getCollectionFields(collectionName);
-  const foreignKeyFields = [];
-  const otherFields = [];
-  fields.forEach(field => {
-    if (field.isForeignKey) {
-      foreignKeyFields.push(field);
-    } else {
-      otherFields.push(field);
-    }
-  });
-  for (let i = otherFields.length - 1; i >= 0; i--) {
-    const field = otherFields[i];
-    if (field.type === 'belongsTo') {
-      const foreignKeyField = foreignKeyFields.find(f => f.name === field.foreignKey);
-      if (foreignKeyField) {
-        var _field$uiSchema, _field$uiSchema2;
-        otherFields.splice(i, 0, _objectSpread(_objectSpread(_objectSpread({}, field), foreignKeyField), {}, {
-          uiSchema: _objectSpread(_objectSpread({}, field.uiSchema), {}, {
-            title: (_field$uiSchema = field.uiSchema) !== null && _field$uiSchema !== void 0 && _field$uiSchema.title ? `${compile((_field$uiSchema2 = field.uiSchema) === null || _field$uiSchema2 === void 0 ? void 0 : _field$uiSchema2.title)} ID` : foreignKeyField.name
-          })
-        }));
-      } else {
-        var _field$uiSchema3, _field$uiSchema4;
-        otherFields.splice(i, 0, _objectSpread(_objectSpread({}, field), {}, {
-          name: field.foreignKey,
-          type: 'bigInt',
-          isForeignKey: true,
-          interface: field.interface,
-          uiSchema: _objectSpread(_objectSpread({}, field.uiSchema), {}, {
-            title: (_field$uiSchema3 = field.uiSchema) !== null && _field$uiSchema3 !== void 0 && _field$uiSchema3.title ? `${compile((_field$uiSchema4 = field.uiSchema) === null || _field$uiSchema4 === void 0 ? void 0 : _field$uiSchema4.title)} ID` : field.name
-          })
-        }));
-      }
-    } else if (field.type === 'context' && field.collectionName === 'users') {
-      var _otherFields$find, _belongsToField$uiSch, _belongsToField$uiSch2;
-      const belongsToField = (_otherFields$find = otherFields.find(f => f.type === 'belongsTo' && f.target === 'users' && f.foreignKey === field.name)) !== null && _otherFields$find !== void 0 ? _otherFields$find : {};
-      otherFields.splice(i, 0, _objectSpread(_objectSpread({}, field), {}, {
-        type: field.dataType,
-        interface: belongsToField.interface,
-        uiSchema: _objectSpread(_objectSpread({}, belongsToField.uiSchema), {}, {
-          title: (_belongsToField$uiSch = belongsToField.uiSchema) !== null && _belongsToField$uiSch !== void 0 && _belongsToField$uiSch.title ? `${compile((_belongsToField$uiSch2 = belongsToField.uiSchema) === null || _belongsToField$uiSch2 === void 0 ? void 0 : _belongsToField$uiSch2.title)} ID` : field.name
-        })
-      }));
-    }
-  }
-  return otherFields.filter(field => field.interface && !field.hidden);
-}
-function loadChildren(_x) {
-  return _loadChildren.apply(this, arguments);
-}
-function _loadChildren() {
-  _loadChildren = _asyncToGenerator(function* (option) {
-    const result = getCollectionFieldOptions(_objectSpread({
-      collection: option.field.target,
-      types: option.types,
-      appends: getNextAppends(option.field, option.appends)
-    }, this));
-    option.loadChildren = null;
-    if (result.length) {
-      option.children = result;
-    } else {
-      var _option$types;
-      option.isLeaf = true;
-      const matchingType = (_option$types = option.types) === null || _option$types === void 0 ? void 0 : _option$types.some(type => matchFieldType(option.field, type, 0));
-      if (!matchingType) {
-        option.disabled = true;
-      }
-    }
-  });
-  return _loadChildren.apply(this, arguments);
-}
-function getCollectionFieldOptions(options) {
-  const fields = options.fields,
-    collection = options.collection,
-    types = options.types,
-    _options$appends = options.appends,
-    appends = _options$appends === void 0 ? [] : _options$appends,
-    compile = options.compile,
-    getCollectionFields = options.getCollectionFields,
-    _options$fieldNames3 = options.fieldNames,
-    fieldNames = _options$fieldNames3 === void 0 ? defaultFieldNames : _options$fieldNames3;
-  const normalizedFields = getNormalizedFields(collection, {
-    compile,
-    getCollectionFields
-  });
-  const computedFields = fields !== null && fields !== void 0 ? fields : normalizedFields;
-  const boundLoadChildren = loadChildren.bind({
-    compile,
-    getCollectionFields,
-    fieldNames
-  });
-  const result = filterTypedFields({
-    fields: computedFields,
-    types,
-    // depth,
-    appends,
-    compile,
-    getCollectionFields
-  }).map(field => {
-    var _field$uiSchema5;
-    const label = compile(((_field$uiSchema5 = field.uiSchema) === null || _field$uiSchema5 === void 0 ? void 0 : _field$uiSchema5.title) || field.name);
-    // console.log('===', label, field);
-    const nextAppends = getNextAppends(field, appends);
-    // TODO: no matching fields in next appends should consider isLeaf as true
-    const isLeaf = !isAssociationField(field) || !nextAppends.length && !appends.includes(field.name);
-    return {
-      [fieldNames.label]: label,
-      key: field.name,
-      [fieldNames.value]: field.name,
-      isLeaf,
-      loadChildren: isLeaf ? null : boundLoadChildren,
-      field,
-      // depth,
-      appends,
-      types
-    };
-  });
-  return result;
-}

package/lib/index.js

@@ -1,13 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-Object.defineProperty(exports, "default", {
-  enumerable: true,
-  get: function get() {
-    return _server.default;
-  }
-});
-var _server = _interopRequireDefault(require("./server"));
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

package/lib/locale/en-US.js

@@ -1,136 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-var _default = {
-  Workflow: 'Workflow',
-  'Execution history': 'Execution history',
-  Executed: 'Executed',
-  'Trigger type': 'Trigger type',
-  Status: 'Status',
-  On: 'On',
-  Off: 'Off',
-  Version: 'Version',
-  'Copy to new version': 'Copy to new version',
-  Duplicate: 'Duplicate',
-  Loading: 'Loading',
-  'Load failed': 'Load failed',
-  Trigger: 'Trigger',
-  'Trigger variables': 'Trigger variables',
-  'Trigger data': 'Trigger data',
-  'Trigger time': 'Trigger time',
-  'Triggered at': 'Triggered at',
-  'Collection event': 'Collection event',
-  'Trigger on': 'Trigger on',
-  'After record added': 'After record added',
-  'After record updated': 'After record updated',
-  'After record added or updated': 'After record added or updated',
-  'After record deleted': 'After record deleted',
-  'Changed fields': 'Changed fields',
-  'Triggered only if one of the selected fields changes. If unselected, it means that it will be triggered when any field changes. When record is added or deleted, any field is considered to have been changed.': 'Triggered only if one of the selected fields changes. If unselected, it means that it will be triggered when any field changes. When record is added or deleted, any field is considered to have been changed.',
-  'Only triggers when match conditions': 'Only triggers when match conditions',
-  'Schedule event': 'Schedule event',
-  'Trigger mode': 'Trigger mode',
-  'Based on certain date': 'Based on certain date',
-  'Based on date field of collection': 'Based on date field of collection',
-  'Starts on': 'Starts on',
-  'Ends on': 'Ends on',
-  'No end': 'No end',
-  'Exactly at': 'Exactly at',
-  'Repeat mode': 'Repeat mode',
-  'Repeat limit': 'Repeat limit',
-  'No limit': 'No limit',
-  Seconds: 'Seconds',
-  Minutes: 'Minutes',
-  Hours: 'Hours',
-  Days: 'Days',
-  Weeks: 'Weeks',
-  Months: 'Months',
-  'No repeat': 'No repeat',
-  Every: 'Every',
-  'By minute': 'By minute',
-  'By hour': 'By hour',
-  'By day': 'By day',
-  'By week': 'By week',
-  'By month': 'By month',
-  'By field': 'By field',
-  'By custom date': 'By custom date',
-  Advanced: 'Advanced',
-  End: 'End',
-  'Node result': 'Node result',
-  Constant: 'Constant',
-  Null: 'Null',
-  Boolean: 'Boolean',
-  String: 'String',
-  Calculator: 'Calculator',
-  'Arithmetic calculation': 'Arithmetic calculation',
-  'String operation': 'String operation',
-  'Executed at': 'Executed at',
-  Queueing: 'Queueing',
-  'On going': 'On going',
-  Succeeded: 'Succeeded',
-  Failed: 'Failed',
-  Pending: 'Pending',
-  Canceled: 'Canceled',
-  'This node contains branches, deleting will also be preformed to them, are you sure?': 'This node contains branches, deleting will also be preformed to them, are you sure?',
-  Control: 'Control',
-  'Collection operations': 'Collection operations',
-  'Extended types': 'Extended types',
-  'Node type': 'Node type',
-  Calculation: 'Calculation',
-  'Configure calculation': 'Configure calculation',
-  'Calculation result': 'Calculation result',
-  True: 'True',
-  False: 'False',
-  concat: 'concat',
-  Condition: 'Condition',
-  Mode: 'Mode',
-  'Continue when "Yes"': 'Continue when "Yes"',
-  'Branch into "Yes" and "No"': 'Branch into "Yes" and "No"',
-  Conditions: 'Conditions',
-  'Parallel branch': 'Parallel branch',
-  'Add branch': 'Add branch',
-  'All succeeded': 'All succeeded',
-  'Any succeeded': 'Any succeeded',
-  'Any succeeded or failed': 'Any succeeded or failed',
-  'Continue after all branches succeeded': 'Continue after all branches succeeded',
-  'Continue after any branch succeeded': 'Continue after any branch succeeded',
-  'Continue after any branch succeeded, or exit after any branch failed': 'Continue after any branch succeeded, or exit after any branch failed',
-  Delay: 'Delay',
-  Duration: 'Duration',
-  'End Status': 'End Status',
-  'Select status': 'Select status',
-  'Succeed and continue': 'Succeed and continue',
-  'Fail and exit': 'Fail and exit',
-  'Create record': 'Create record',
-  'Update record': 'Update record',
-  'Query record': 'Query record',
-  'Multiple records': 'Multiple records',
-  'Please select collection first': 'Please select collection first',
-  'Only update records matching conditions': 'Only update records matching conditions',
-  'Fields that are not assigned a value will be set to the default value, and those that do not have a default value are set to null.': 'Fields that are not assigned a value will be set to the default value, and those that do not have a default value are set to null.',
-  'Trigger in executed workflow cannot be modified': 'Trigger in executed workflow cannot be modified',
-  'Node in executed workflow cannot be modified': 'Node in executed workflow cannot be modified',
-  'Can not delete': 'Can not delete',
-  'The result of this node has been referenced by other nodes ({{nodes}}), please remove the usage before deleting.': 'The result of this node has been referenced by other nodes ({{nodes}}), please remove the usage before deleting.',
-  'HTTP request': 'HTTP request',
-  'HTTP method': 'HTTP method',
-  URL: 'URL',
-  Headers: 'Headers',
-  'Add request header': 'Add request header',
-  Parameters: 'Parameters',
-  'Add parameter': 'Add parameter',
-  Body: 'Body',
-  'Use variable': 'Use variable',
-  Format: 'Format',
-  Insert: 'Insert',
-  'Timeout config': 'Timeout config',
-  ms: 'ms',
-  'Input request data': 'Input request data',
-  'Only support standard JSON data': 'Only support standard JSON data',
-  '"Content-Type" only support "application/json", and no need to specify': '"Content-Type" only support "application/json", and no need to specify',
-  'Ignore fail request and continue workflow': 'Ignore fail request and continue workflow'
-};
-exports.default = _default;

package/lib/locale/fr-FR.js

@@ -1,136 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-var _default = {
-  Workflow: 'Workflow',
-  'Execution history': "Historique d'exécution",
-  Executed: 'Exécuté',
-  'Trigger type': 'Type de déclencheur',
-  Status: 'Statut',
-  On: 'Activé',
-  Off: 'Désactivé',
-  Version: 'Version',
-  'Copy to new version': 'Copier vers une nouvelle version',
-  Duplicate: 'Dupliquer',
-  Loading: 'Chargement',
-  'Load failed': 'Échec du chargement',
-  Trigger: 'Déclencheur',
-  'Trigger variables': 'Variables de déclenchement',
-  'Trigger data': 'Données de déclenchement',
-  'Trigger time': 'Temps de déclenchement',
-  'Triggered at': 'Déclenché à',
-  'Collection event': 'Événement de collection',
-  'Trigger on': 'Déclencher sur',
-  'After record added': "Après l'ajout d'un enregistrement",
-  'After record updated': "Après la mise à jour d'un enregistrement",
-  'After record added or updated': "Après l'ajout ou la mise à jour d'un enregistrement",
-  'After record deleted': "Après la suppression d'un enregistrement",
-  'Changed fields': 'Champs modifiés',
-  'Triggered only if one of the selected fields changes. If unselected, it means that it will be triggered when any field changes. When record is added or deleted, any field is considered to have been changed.': "Déclenché uniquement si l'un des champs sélectionnés change. S'il n'est pas sélectionné, cela signifie qu'il sera déclenché lorsque n'importe quel champ change. Lorsque l'enregistrement est ajouté ou supprimé, n'importe quel champ est considéré comme ayant été modifié.",
-  'Only triggers when match conditions': 'Déclenche uniquement lorsque les conditions correspondent',
-  'Schedule event': 'Événement planifié',
-  'Trigger mode': 'Mode de déclenchement',
-  'Based on certain date': 'Basé sur une date spécifique',
-  'Based on date field of collection': 'Basé sur le champ de date de la collection',
-  'Starts on': 'Commence le',
-  'Ends on': 'Se termine le',
-  'No end': 'Pas de fin',
-  'Exactly at': 'Exactement à',
-  'Repeat mode': 'Mode de répétition',
-  'Repeat limit': 'Limite de répétition',
-  'No limit': 'Pas de limite',
-  Seconds: 'Secondes',
-  Minutes: 'Minutes',
-  Hours: 'Heures',
-  Days: 'Jours',
-  Weeks: 'Semaines',
-  Months: 'Mois',
-  'No repeat': 'Pas de répétition',
-  Every: 'Chaque',
-  'By minute': 'Par minute',
-  'By hour': 'Par heure',
-  'By day': 'Par jour',
-  'By week': 'Par semaine',
-  'By month': 'Par mois',
-  'By field': 'Par champ',
-  'By custom date': 'Par date personnalisée',
-  Advanced: 'Avancé',
-  End: 'Fin',
-  'Node result': 'Résultat du nœud',
-  Constant: 'Constante',
-  Null: 'Null',
-  Boolean: 'Booléen',
-  String: 'Chaîne de caractères',
-  Calculator: 'Calculatrice',
-  'Arithmetic calculation': 'Calcul arithmétique',
-  'String operation': 'Opération sur les chaînes de caractères',
-  'Executed at': 'Exécuté à',
-  Queueing: 'En attente',
-  'On going': 'En cours',
-  Succeeded: 'Réussi',
-  Failed: 'Échoué',
-  Pending: 'En attente',
-  Canceled: 'Annulé',
-  'This node contains branches, deleting will also be preformed to them, are you sure?': 'Ce nœud contient des branches, leur suppression sera également effectuée, êtes-vous sûr(e) ?',
-  Control: 'Contrôle',
-  'Collection operations': 'Opérations sur la collection',
-  'Extended types': 'Types étendus',
-  'Node type': 'Type de nœud',
-  Calculation: 'Calcul',
-  'Configure calculation': 'Configurer le calcul',
-  'Calculation result': 'Résultat du calcul',
-  True: 'Vrai',
-  False: 'Faux',
-  concat: 'concat',
-  Condition: 'Condition',
-  Mode: 'Mode',
-  'Continue when "Yes"': 'Continuer quand "Oui"',
-  'Branch into "Yes" and "No"': 'Brancher sur "Oui" et "Non"',
-  Conditions: 'Conditions',
-  'Parallel branch': 'Branche parallèle',
-  'Add branch': 'Ajouter une branche',
-  'All succeeded': 'Tous réussis',
-  'Any succeeded': 'Un réussi',
-  'Any succeeded or failed': 'Un réussi ou un échoué',
-  'Continue after all branches succeeded': 'Continuer après la réussite de toutes les branches',
-  'Continue after any branch succeeded': "Continuer après la réussite d'une branche",
-  'Continue after any branch succeeded, or exit after any branch failed': "Continuer après la réussite d'une branche, ou quitter après l'échec d'une branche",
-  Delay: 'Délai',
-  Duration: 'Durée',
-  'End Status': 'Statut de fin',
-  'Select status': 'Sélectionner un statut',
-  'Succeed and continue': 'Réussir et continuer',
-  'Fail and exit': 'Échouer et quitter',
-  'Create record': 'Créer un enregistrement',
-  'Update record': 'Mettre à jour un enregistrement',
-  'Query record': 'Interroger un enregistrement',
-  'Multiple records': 'Multiples enregistrements',
-  'Please select collection first': "Veuillez d'abord sélectionner une collection",
-  'Only update records matching conditions': 'Mettre à jour uniquement les enregistrements correspondant aux conditions',
-  'Fields that are not assigned a value will be set to the default value, and those that do not have a default value are set to null.': "Les champs qui ne reçoivent pas de valeur seront définis sur la valeur par défaut, et ceux qui n'ont pas de valeur par défaut seront définis sur null.",
-  'Trigger in executed workflow cannot be modified': 'Le déclencheur dans le workflow exécuté ne peut pas être modifié',
-  'Node in executed workflow cannot be modified': 'Le nœud dans le workflow exécuté ne peut pas être modifié',
-  'Can not delete': 'Impossible de supprimer',
-  'The result of this node has been referenced by other nodes ({{nodes}}), please remove the usage before deleting.': "Le résultat de ce nœud a été référencé par d'autres nœuds ({{nodes}}), veuillez supprimer son utilisation avant de le supprimer.",
-  'HTTP request': 'Requête HTTP',
-  'HTTP method': 'Méthode HTTP',
-  URL: 'URL',
-  Headers: 'En-têtes',
-  'Add request header': 'Ajouter un en-tête de requête',
-  Parameters: 'Paramètres',
-  'Add parameter': 'Ajouter un paramètre',
-  Body: 'Corps',
-  'Use variable': 'Utiliser une variable',
-  Format: 'Format',
-  Insert: 'Insérer',
-  'Timeout config': "Configuration du délai d'expiration",
-  ms: 'ms',
-  'Input request data': 'Entrée des données de requête',
-  'Only support standard JSON data': 'Prend uniquement en charge les données JSON standard',
-  '"Content-Type" only support "application/json", and no need to specify': '"Content-Type" prend uniquement en charge "application/json" et n\'a pas besoin d\'être spécifié',
-  'Ignore fail request and continue workflow': "Ignorer l'échec de la requête et continuer le workflow"
-};
-exports.default = _default;