logologo
Começar
Manual
Desenvolvimento
Plugins
API
English
简体中文
日本語
한국어
Deutsch
Français
Español
Português
Русский
Italiano
Türkçe
Українська
Tiếng Việt
Bahasa Indonesia
ไทย
Polski
Nederlands
Čeština
العربية
עברית
हिन्दी
Svenska
Começar
Manual
Desenvolvimento
Plugins
API
logologo

Introdução

O que é o FlowEngine?
Relação entre FlowEngine e Plugins
Início Rápido
Roteiro de Aprendizagem

Guia

Registrar FlowModel
Criar FlowModel
Renderizar FlowModel
Fluxo de Eventos e Configuração do FlowModel
Persistência do FlowModel
Ciclo de Vida do FlowModel
Sistema de Contexto do FlowModel
Mecanismo Reativo: Observable
FlowModel vs React.Component

Definições

ModelDefinition
FlowDefinition
EventDefinition
ActionDefinition
StepDefinition
Previous PageActionDefinition
Aviso de tradução por IA

Esta documentação foi traduzida automaticamente por IA.

#StepDefinition

StepDefinition define um único passo em um fluxo. Cada passo pode ser uma ação, um tratamento de evento ou outra operação. Um passo é a unidade de execução básica de um fluxo.

#Definição de Tipo

interface StepDefinition<TModel extends FlowModel = FlowModel>
  extends Partial<Omit<ActionDefinition<TModel, FlowRuntimeContext<TModel>>, 'name'>> {
  key?: string;
  isAwait?: boolean;
  use?: string;
  sort?: number;
  preset?: boolean;
  paramsRequired?: boolean;
  hideInSettings?: boolean;
  uiMode?: StepUIMode | ((ctx: FlowRuntimeContext<TModel>) => StepUIMode | Promise<StepUIMode>);
}

#Uso

class MyModel extends FlowModel {}

MyModel.registerFlow({
  key: 'pageSettings',
  steps: {
    step1: {
      use: 'actionName',
      title: 'First Step',
      sort: 0,
      preset: true
    },
    step2: {
      handler: async (ctx, params) => {
        // Lógica de processamento personalizada
        return { result: 'success' };
      },
      title: 'Second Step',
      sort: 1
    }
  }
});

#Descrição das Propriedades

#key

Tipo: string
Obrigatório: Não
Descrição: O identificador único para o passo dentro do fluxo.

Se não for fornecido, o nome da chave do passo no objeto steps será usado.

Exemplo:

steps: {
  loadData: {  // key é 'loadData'
    use: 'loadDataAction'
  }
}

#use

Tipo: string
Obrigatório: Não
Descrição: O nome de uma ActionDefinition registrada a ser usada.

A propriedade use permite que você referencie uma ação registrada, evitando definições duplicadas.

Exemplo:

// Primeiro, registre a ação
MyModel.registerAction({
  name: 'loadDataAction',
  handler: async (ctx, params) => {
    // Lógica de carregamento de dados
  }
});

// Use-a em um passo
steps: {
  step1: {
    use: 'loadDataAction',  // Referencia a ação registrada
    title: 'Load Data'
  }
}

#title

Tipo: string
Obrigatório: Não
Descrição: O título de exibição do passo.

Usado para exibição na interface do usuário e depuração.

Exemplo:

title: 'Load Data'
title: 'Process Information'
title: 'Save Results'

#sort

Tipo: number
Obrigatório: Não
Descrição: A ordem de execução do passo. Quanto menor o valor, mais cedo ele será executado.

Usado para controlar a ordem de execução de múltiplos passos no mesmo fluxo.

Exemplo:

steps: {
  step1: { sort: 0 },  // Executa primeiro
  step2: { sort: 1 },  // Executa em seguida
  step3: { sort: 2 }   // Executa por último
}

#handler

Tipo: (ctx: FlowRuntimeContext<TModel>, params: any) => Promise<any> | any
Obrigatório: Não
Descrição: A função de tratamento para o passo.

Quando a propriedade use não é usada, você pode definir a função de tratamento diretamente.

Exemplo:

handler: async (ctx, params) => {
  // Obtenha informações de contexto
  const { model, flowEngine } = ctx;
  
  // Lógica de processamento
  const result = await processData(params);
  
  // Retorne o resultado
  return { success: true, data: result };
}

#defaultParams

Tipo: Record<string, any> | ((ctx: FlowRuntimeContext<TModel>) => Record<string, any> | Promise<Record<string, any>>)
Obrigatório: Não
Descrição: Os parâmetros padrão para o passo.

Preenche os parâmetros com valores padrão antes que o passo seja executado.

Exemplo:

// Parâmetros padrão estáticos
defaultParams: {
  timeout: 5000,
  retries: 3,
  format: 'json'
}

// Parâmetros padrão dinâmicos
defaultParams: (ctx) => {
  return {
    userId: ctx.model.uid,
    timestamp: Date.now()
  }
}

// Parâmetros padrão assíncronos
defaultParams: async (ctx) => {
  const config = await loadConfig();
  return {
    apiUrl: config.apiUrl,
    apiKey: config.apiKey
  }
}

#uiSchema

Tipo: Record<string, ISchema> | ((ctx: FlowRuntimeContext<TModel>) => Record<string, ISchema> | Promise<Record<string, ISchema>>)
Obrigatório: Não
Descrição: O esquema de configuração da UI para o passo.

Define como o passo é exibido na interface e sua configuração de formulário.

Exemplo:

uiSchema: {
  'x-component': 'Form',
  'x-component-props': {
    layout: 'vertical'
  },
  properties: {
    name: {
      type: 'string',
      title: 'Name',
      'x-component': 'Input'
    },
    age: {
      type: 'number',
      title: 'Age',
      'x-component': 'InputNumber'
    }
  }
}

#beforeParamsSave

Tipo: (ctx: FlowSettingsContext<TModel>, params: any, previousParams: any) => void | Promise<void>
Obrigatório: Não
Descrição: Uma função de hook que é executada antes que os parâmetros sejam salvos.

Executa antes que os parâmetros do passo sejam salvos, e pode ser usada para validação ou transformação de parâmetros.

Exemplo:

beforeParamsSave: (ctx, params, previousParams) => {
  // Validação de parâmetros
  if (!params.name) {
    throw new Error('Name is required');
  }
  
  // Transformação de parâmetros
  params.name = params.name.trim().toLowerCase();
}

#afterParamsSave

Tipo: (ctx: FlowSettingsContext<TModel>, params: any, previousParams: any) => void | Promise<void>
Obrigatório: Não
Descrição: Uma função de hook que é executada depois que os parâmetros são salvos.

Executa depois que os parâmetros do passo são salvos, e pode ser usada para disparar outras operações.

Exemplo:

afterParamsSave: (ctx, params, previousParams) => {
  // Registra logs
  console.log('Step params saved:', params);
  
  // Dispara outras operações
  ctx.model.emitter.emit('paramsChanged', params);
}

#uiMode

Tipo: StepUIMode | ((ctx: FlowRuntimeContext<TModel>) => StepUIMode | Promise<StepUIMode>)
Obrigatório: Não
Descrição: O modo de exibição da UI para o passo.

Controla como o passo é exibido na interface.

Modos suportados:

  • 'dialog' - Modo de diálogo
  • 'drawer' - Modo de gaveta
  • 'embed' - Modo incorporado
  • Ou um objeto de configuração personalizado

Exemplo:

// Modo simples
uiMode: 'dialog'

// Configuração personalizada
uiMode: {
  type: 'dialog',
  props: {
    width: 800,
    title: 'Step Configuration'
  }
}

// Modo dinâmico
uiMode: (ctx) => {
  return ctx.model.isMobile ? 'drawer' : 'dialog';
}

#preset

Tipo: boolean
Obrigatório: Não
Descrição: Indica se é um passo predefinido.

Os parâmetros para passos com preset: true precisam ser preenchidos no momento da criação. Aqueles sem essa flag podem ser preenchidos após a criação do modelo.

Exemplo:

steps: {
  step1: {
    preset: true,  // Os parâmetros devem ser preenchidos no momento da criação
    use: 'requiredAction'
  },
  step2: {
    preset: false, // Os parâmetros podem ser preenchidos posteriormente
    use: 'optionalAction'
  }
}

#paramsRequired

Tipo: boolean
Obrigatório: Não
Descrição: Indica se os parâmetros do passo são obrigatórios.

Se true, uma caixa de diálogo de configuração será aberta antes de adicionar o modelo.

Exemplo:

paramsRequired: true  // Os parâmetros devem ser configurados antes de adicionar o modelo
paramsRequired: false // Os parâmetros podem ser configurados posteriormente

#hideInSettings

Tipo: boolean
Obrigatório: Não
Descrição: Indica se o passo deve ser ocultado no menu de configurações.

Exemplo:

hideInSettings: true  // Ocultar nas configurações
hideInSettings: false // Mostrar nas configurações (padrão)

#isAwait

Tipo: boolean
Obrigatório: Não
Padrão: true
Descrição: Indica se deve aguardar a conclusão da função de tratamento.

Exemplo:

isAwait: true  // Aguarda a conclusão da função de tratamento (padrão)
isAwait: false // Não aguarda, executa assincronamente

#Exemplo Completo

class DataProcessingModel extends FlowModel {}

DataProcessingModel.registerFlow({
  key: 'dataProcessing',
  title: 'Data Processing',
  steps: {
    loadData: {
      use: 'loadDataAction',
      title: 'Load Data',
      sort: 0,
      preset: true,
      paramsRequired: true,
      defaultParams: {
        source: 'api',
        timeout: 5000
      },
      uiMode: 'dialog'
    },
    processData: {
      handler: async (ctx, params) => {
        const data = await ctx.model.getData();
        return processData(data, params);
      },
      title: 'Process Data',
      sort: 1,
      defaultParams: (ctx) => ({
        userId: ctx.model.uid,
        timestamp: Date.now()
      }),
      beforeParamsSave: (ctx, params) => {
        if (!params.processor) {
          throw new Error('Processor is required');
        }
      },
      afterParamsSave: (ctx, params) => {
        ctx.model.emitter.emit('dataProcessed', params);
      }
    },
    saveData: {
      use: 'saveDataAction',
      title: 'Save Data',
      sort: 2,
      hideInSettings: false,
      uiMode: {
        type: 'drawer',
        props: {
          width: 600,
          title: 'Save Configuration'
        }
      }
    }
  }
});