Documentation SCFlow

Utiliser SCFlow

• Le graphe de flux — Read and edit a supply chain flow on the graph: lanes, actors, flows and the entity palette.
• Interroger l’assistant d’aide — Ask the AI help assistant how to do something; it reads the documentation and the commands of the application.
• Exécuter une commande — Find and run any command with the command palette, and see its keyboard shortcut.
• Supply chain flow: concepts — The concepts of Supply chain flow and their relations, generated from the schemas of scflow:core.
• Panneau Documents — Open, create, save and close documents, and open their views, from the Documents panel.
• Utiliser le panneau d’aide — Open help with F1 on any panel or view, search the topics and follow links between them.
• Changer de langue — Switch the interface between English and French; the change applies at once.
• Gestionnaire de plugins — See the installed plugins, enable or disable them and add new ones.
• Panneau Propriétés — Edit the properties of whatever is selected in a view or a panel.
• Réglages — Open the settings and change the preferences of the workspace and of each plugin.
• Annuler et rétablir — Undo and redo the changes made to the open document with the keyboard or the commands.

Développer des plugins

• Semantic actions — Register actions with ctx.actions that run in one transaction, from the UI, scripts and AI.
• Adding a language — Declare a locale, add the shell catalogue and the plugin catalogues.
• The AI assistant and AI help — Create an assistant, declare it in ui.json and give it tools.
• Documentation for AI assistants — Let an assistant read documentation through the read_docs tool, filtered by audience.
• Assistant instructions and conversation scripts — Optional project instructions and replayable conversation scripts for an assistant.
• AI skills — Owner-scoped Markdown skills and host skill catalogues an assistant loads with use_skill.
• Architecture: packages, plugins and the shell — Les trois couches de l’application : paquets de logique pure, plugins d’adaptation, kernel et shell.
• Building the app outside Lovable — Build and run the web app, the desktop app and the plugins with Bun.
• Bundled plugins with React and JSX — Ship a plugin with the application, written with React, TypeScript and JSX.
• Core events — The events the kernel and the shell emit, for plugins that observe or react to them.
• Running the app as a desktop app — Run and package the Tauri 2 desktop app that reuses the shell, plugins and store.
• Help and documentation topics — Write documentation topics, register a source and attach help keys to the interface.
• The documents plugin — Open, create, save and close documents through the built-in documents plugin, and extend it with document types.
• Developing a plugin in a separate repository — Install the public plugin types and wire a plugin’s tsconfig outside the framework repository.
• Graph views and automatic layouts — Work on any open graph through ctx.graphs: fit all, automatic layouts and cross-plugin references.
• Graphs — Declare graphs: positioned nodes, directed edges, swimlanes, annotations, legend, guides and orientation.
• Installing plugins at runtime — Load a plugin from a URL or a local file while the application runs.
• Logging and traces — Read the log level from a plugin and write logs and traces.
• Menus, toolbars and command placements — Place commands in the menus, toolbars and context menus, with targets, state sources and context.
• Writing UI in plain JavaScript — Build plugin UI with ctx.h and no JSX or build step.
• Writing a plugin — The shape of a plugin: a module with a default export, setup(ctx), and the one-way flow from UI action to event to handler to state.
• Dependencies between plugins — Declare dependsOn, expose a public API and use another plugin’s API in a typed way.
• The plugin space and registries — How plugins are scanned at startup and where the registries list what they contribute.
• Selections and the properties panel — Publish a selection and contribute forms for a selection kind to the one properties panel of the shell.
• Plugin resources — Read JSON, text and binary files bundled with a plugin through ctx.resources.
• Sample plugins — The sample plugins of the repository and what each one shows.
• Plugin settings — Declare settings sections and fields, and read and watch their values.
• Declarative shape palettes — Declare palettes of shapes to drop onto a graph, and use them as selection sources.
• Packages and sharing them between plugins — Keep data and logic in packages outside plugins and share one instance between plugins.
• Structuring a larger plugin — Split a growing plugin into env.ts, bindings.ts, handlers and a thin index.
• Tables — Declare typed tables: columns, sorting, filters, editing rows, large data and sub-rows.
• Enregistrer et rejouer des scénarios d’événements — Enregistrer, rejouer et tester des scénarios d’événements avec le kernel sans interface.
• Toolbar widgets — Place an input, rather than a button, in a toolbar and bind it to a value.
• Transactions and events — Primary events, the two-phase transaction commit, and why undo and redo belong to the plugin.
• Transfer between views — Drag and drop, copy and paste between views, and frozen columns, export and import.
• Translations in a plugin — Declare i18n messages for a plugin, translate keys and add plugin catalogues.
• Trees, lists and declarative panels — Declare reactive trees and lists fed by a slice path, and the panels that host them.
• Writing a plugin in TypeScript and JSX — The recommended way to write a plugin: TypeScript and JSX bundled by the shell tooling.
• Shell UI components — Which shell component (toolbar, tree, table, graph, form) a plugin declares for what, and where each is documented.
• The interface as a JSON file (ui.json) — Declare commands, menus, toolbars, panels, views, settings and translations of a plugin in ui.json.
• UI studio — Edit a plugin’s ui.json visually.
• Value types — Register value types that tables, forms, widgets and settings use to display and edit values.
• Work-area views and view engines — Register views that work-area tabs open, and the engines that render them.
• Web and desktop differences — What changes for a plugin between the browser build and the Tauri desktop build.

Développer des modèles et modules

• Conventions of the actions — References by id or name, localized texts, atomic undoable calls, the write limit, rules and the cascade of deletes, shared by every action of scflow:core.
• Supply chain flow: actions — The actions of Supply chain flow with their parameters and example calls, generated from the declarations of scflow:core.