@formicoidea/labre-framework-edgy 0.35.0 → 0.37.0

package/dist/commands.js

@@ -24,6 +24,7 @@ const SPECS = [
         iconKey: 'edgy.board',
         category: 'diagrams',
         element: 'board',
+        board: true,
         run: createEdgyBoard,
     },
     {
@@ -89,7 +90,7 @@ export const edgyCommands = SPECS.map((spec, order) => ({
     defaultKeys: { mac: [], other: [] },
     availability: 'always',
     run: spec.run,
-    telemetry: { framework: 'edgy', element: spec.element },
+    telemetry: { framework: 'edgy', element: spec.element, board: spec.board },
 }));
 export const edgyCommandIcons = {
     'edgy.facets': edgyFacetsIcon,

package/dist/index.d.ts

@@ -1,2 +1,4 @@
 export { edgyCommandIcons, edgyCommands } from './commands.js';
 export { edgyTranslationEntries } from './translations.js';
+export { EDGY_ROLE, EDGY_ROLES, type EdgyRoleId } from './roles.js';
+export { EDGY_READING } from './reading.js';

package/dist/index.js

@@ -1,2 +1,6 @@
 export { edgyCommandIcons, edgyCommands } from './commands.js';
 export { edgyTranslationEntries } from './translations.js';
+// The role vocabulary and the reading profile: DATA a host — and the
+// library's own cross-framework guard test — can read without an editor.
+export { EDGY_ROLE, EDGY_ROLES } from './roles.js';
+export { EDGY_READING } from './reading.js';

package/dist/reading.d.ts

@@ -0,0 +1,44 @@
+import type { ReadingProfile } from '@formicoidea/labre-core/blocks/surface';
+/**
+ * What EDGY lets the tool read of an element (MF3, the reversed reading).
+ *
+ * DATA, like the rules and the profiles beside it: the engine
+ * (`@labre/affine-block-surface`) knows how to read a role and a typed edge — it
+ * knows nothing about EDGY. Everything below is already stated in `roles.ts` and
+ * is merely POINTED AT here.
+ *
+ * Registered from the FLAG-GATED view extension: reading a board is tooling, so
+ * a board whose EDGY flag is off keeps every element it has and simply stops
+ * being read (ADR 0009).
+ *
+ * ## One subject, sixteen kinds
+ *
+ * `edgy:element` is the root of the four persisted kinds and the twelve official
+ * elements, and `readingProfileFor` resolves through `roleIsA` — so one profile
+ * reads all sixteen, and the panel's type line says which one AND the chain
+ * above it ("Journey › Activity › Element"). The three FRAMES (`edgy:background`
+ * and its two children) stay out for the reason they are not children of
+ * `edgy:element`: a reading is about an artefact, never about the sheet it is
+ * drawn on.
+ *
+ * ## No nature, no phase
+ *
+ * EDGY ships no type-3 tag pack: its kinds ARE the roles, and the panel already
+ * says them on the type line. And its board declares no zones — the facets
+ * diagram is a legend, not a plotted axis — so there is nothing a position could
+ * be read against. Both sections are therefore absent rather than empty, which
+ * is the whole discipline of this feature: a reading offers what the document
+ * states and never a heading with nothing under it.
+ */
+/**
+ * ## Why the two sides are named after the DIRECTION and not after a verb
+ *
+ * EDGY has 22 canonical verbs and the relation between two elements is entirely
+ * determined by the pair they run between (`EDGY_PAIR_TO_VERB`). There is no one
+ * word that names "what this element points at" across "requires", "is part of"
+ * and "delivers" — so the panel says the only thing that is true of all 22:
+ * which way the arrow runs. ADR 0010 tier 1 fixes what that means — the source
+ * is the subject of the verb — and the verb itself is already on the link's own
+ * chip, where the user drew it.
+ */
+export declare const EDGY_READING: ReadingProfile;

package/dist/reading.js

@@ -0,0 +1,64 @@
+import { EDGY_ROLE, EDGY_ROLES } from './roles.js';
+/**
+ * What EDGY lets the tool read of an element (MF3, the reversed reading).
+ *
+ * DATA, like the rules and the profiles beside it: the engine
+ * (`@labre/affine-block-surface`) knows how to read a role and a typed edge — it
+ * knows nothing about EDGY. Everything below is already stated in `roles.ts` and
+ * is merely POINTED AT here.
+ *
+ * Registered from the FLAG-GATED view extension: reading a board is tooling, so
+ * a board whose EDGY flag is off keeps every element it has and simply stops
+ * being read (ADR 0009).
+ *
+ * ## One subject, sixteen kinds
+ *
+ * `edgy:element` is the root of the four persisted kinds and the twelve official
+ * elements, and `readingProfileFor` resolves through `roleIsA` — so one profile
+ * reads all sixteen, and the panel's type line says which one AND the chain
+ * above it ("Journey › Activity › Element"). The three FRAMES (`edgy:background`
+ * and its two children) stay out for the reason they are not children of
+ * `edgy:element`: a reading is about an artefact, never about the sheet it is
+ * drawn on.
+ *
+ * ## No nature, no phase
+ *
+ * EDGY ships no type-3 tag pack: its kinds ARE the roles, and the panel already
+ * says them on the type line. And its board declares no zones — the facets
+ * diagram is a legend, not a plotted axis — so there is nothing a position could
+ * be read against. Both sections are therefore absent rather than empty, which
+ * is the whole discipline of this feature: a reading offers what the document
+ * states and never a heading with nothing under it.
+ */
+/**
+ * ## Why the two sides are named after the DIRECTION and not after a verb
+ *
+ * EDGY has 22 canonical verbs and the relation between two elements is entirely
+ * determined by the pair they run between (`EDGY_PAIR_TO_VERB`). There is no one
+ * word that names "what this element points at" across "requires", "is part of"
+ * and "delivers" — so the panel says the only thing that is true of all 22:
+ * which way the arrow runs. ADR 0010 tier 1 fixes what that means — the source
+ * is the subject of the verb — and the verb itself is already on the link's own
+ * chip, where the user drew it.
+ */
+export const EDGY_READING = {
+    id: 'edgy',
+    framework: 'edgy',
+    roles: EDGY_ROLES,
+    appliesTo: EDGY_ROLE.element,
+    relation: {
+        // The parent of the 22 verb roles: a rule of `roleIsA` away from every one
+        // of them, which is why the vocabulary declares it.
+        edgeRole: EDGY_ROLE.relation,
+        sides: {
+            consumer: {
+                labelKey: 'com.labre.edgy.reading.relations.consumer',
+                labelFallback: 'Incoming relations',
+            },
+            supplier: {
+                labelKey: 'com.labre.edgy.reading.relations.supplier',
+                labelFallback: 'Outgoing relations',
+            },
+        },
+    },
+};

package/dist/toolbar/node-config.js

@@ -1,11 +1,6 @@
-import { EdgelessCRUDIdentifier } from '@formicoidea/labre-core/blocks/surface';
-import { packColor, } from '@formicoidea/labre-core/components/color-picker';
-import { shapeToolbarConfig } from '@formicoidea/labre-core/gfx/shape';
-import { DefaultTheme, isTransparent, LineWidth, resolveColor, ShapeElementModel, StrokeStyle, } from '@formicoidea/labre-core/model';
+import { neutralPalettes, paletteColorAction, shapeToolbarConfig, } from '@formicoidea/labre-core/gfx/shape';
 import { ToolbarModuleExtension, } from '@formicoidea/labre-core/shared/services';
-import { getMostCommonValue } from '@formicoidea/labre-core/shared/utils';
 import { BlockFlavourIdentifier } from '@formicoidea/labre-core/std';
-import { html } from 'lit';
 /**
  * The typical EDGY palette, surfaced as ready-made swatches in the EDGY node
  * color picker (facet + intersection colours, saturated then pastel), followed
@@ -30,117 +25,12 @@ const EDGY_PALETTES = [
  * black, transparent) — the historical colours are dropped in favour of the
  * EDGY swatches above.
  */
-const NEUTRAL_KEY = /grey|gray|white|black|transparent/i;
-const EDGY_PALETTE_LIST = [
-    ...EDGY_PALETTES,
-    ...DefaultTheme.Palettes.filter(p => NEUTRAL_KEY.test(p.key)),
-];
-// Mirror of the shape color action's text-color rule.
-function getTextColor(fillColor) {
-    if (fillColor === DefaultTheme.black)
-        return DefaultTheme.white;
-    if (fillColor === DefaultTheme.white)
-        return DefaultTheme.black;
-    return DefaultTheme.shapeTextColor;
-}
+const EDGY_PALETTE_LIST = [...EDGY_PALETTES, ...neutralPalettes()];
 /**
  * EDGY fill / stroke colour picker — identical to the shape one but seeded with
  * the EDGY palette swatches (`.palettes`).
  */
-const edgyColorAction = {
-    id: 'e.color',
-    when(ctx) {
-        return ctx.getSurfaceModelsByType(ShapeElementModel).length > 0;
-    },
-    content(ctx) {
-        const models = ctx.getSurfaceModelsByType(ShapeElementModel);
-        if (!models.length)
-            return null;
-        const enableCustomColor = ctx.features.getFlag('enable_color_picker');
-        const theme = ctx.theme.edgeless$.value;
-        const firstModel = models[0];
-        const originalFillColor = firstModel.fillColor;
-        const originalStrokeColor = firstModel.strokeColor;
-        const mapped = models.map(({ filled, fillColor, strokeColor, strokeWidth, strokeStyle }) => ({
-            fillColor: filled
-                ? resolveColor(fillColor, theme)
-                : DefaultTheme.transparent,
-            strokeColor: resolveColor(strokeColor, theme),
-            strokeWidth,
-            strokeStyle,
-        }));
-        const fillColor = getMostCommonValue(mapped, 'fillColor') ??
-            resolveColor(DefaultTheme.shapeFillColor, theme);
-        const strokeColor = getMostCommonValue(mapped, 'strokeColor') ??
-            resolveColor(DefaultTheme.shapeStrokeColor, theme);
-        const strokeWidth = getMostCommonValue(mapped, 'strokeWidth') ?? LineWidth.Four;
-        const strokeStyle = getMostCommonValue(mapped, 'strokeStyle') ?? StrokeStyle.Solid;
-        const pickColorWrapper = (field, pickCallback) => (e) => {
-            e.stopPropagation();
-            switch (e.detail.type) {
-                case 'pick':
-                    pickCallback(e.detail.detail);
-                    break;
-                case 'start':
-                    ctx.store.captureSync();
-                    models.forEach(model => model.stash(field));
-                    break;
-                case 'end':
-                    ctx.store.transact(() => {
-                        models.forEach(model => model.pop(field));
-                    });
-            }
-        };
-        const onPickFillColor = pickColorWrapper('fillColor', palette => {
-            const value = palette.value;
-            const filled = isTransparent(value);
-            const props = packColor('fillColor', value);
-            const crud = ctx.std.get(EdgelessCRUDIdentifier);
-            models.forEach(model => {
-                if (filled && !model.filled) {
-                    const color = getTextColor(value);
-                    Object.assign(props, { filled, color });
-                }
-                crud.updateElement(model.id, props);
-            });
-        });
-        const onPickStrokeColor = pickColorWrapper('strokeColor', palette => {
-            const props = packColor('strokeColor', palette.value);
-            const crud = ctx.std.get(EdgelessCRUDIdentifier);
-            models.forEach(model => crud.updateElement(model.id, props));
-        });
-        const onPickStrokeStyle = (e) => {
-            e.stopPropagation();
-            const { type, value } = e.detail;
-            const crud = ctx.std.get(EdgelessCRUDIdentifier);
-            const props = type === 'size'
-                ? { strokeWidth: value }
-                : { strokeStyle: value };
-            for (const model of models) {
-                crud.updateElement(model.id, props);
-            }
-        };
-        return html `
-      <edgeless-shape-color-picker
-        @pickFillColor=${onPickFillColor}
-        @pickStrokeColor=${onPickStrokeColor}
-        @pickStrokeStyle=${onPickStrokeStyle}
-        .palettes=${EDGY_PALETTE_LIST}
-        .payload=${{
-            fillColor,
-            strokeColor,
-            strokeWidth,
-            strokeStyle,
-            originalFillColor,
-            originalStrokeColor,
-            theme,
-            enableCustomColor,
-        }}
-      >
-      </edgeless-shape-color-picker>
-    `;
-    },
-};
+const edgyColorAction = paletteColorAction('e.color', EDGY_PALETTE_LIST);
 /**
  * EDGY nodes are {@link ShapeElementModel} subclasses, so the shape toolbar's
  * actions operate on them directly. We reuse the line-style + text actions, add

package/dist/translations.js

@@ -3,6 +3,7 @@ import { edgyCommands } from './commands.js';
 import { NODE_LABEL, nodeLabelKey } from './node/consts.js';
 import { EDGY_NUDGES } from './nudges.js';
 import { EDGY_PROFILES } from './profiles.js';
+import { EDGY_READING } from './reading.js';
 import { EDGY_ROLES } from './roles.js';
 import { EDGY_RULES } from './rules.js';
 /**
@@ -41,4 +42,9 @@ Object.entries(NODE_LABEL).map(([kind, label]) => ({
     key: nodeLabelKey(kind),
     fallback: label,
     source: 'seed',
-})));
+})), 
+// LAST, and the order is load-bearing: a reading profile carries the
+// framework's own `roles`, so walking it reaches every role key the line
+// above already named. `mergeTranslationEntries` keeps the FIRST
+// occurrence, which is what makes each key report the source it comes from.
+collectTranslationKeys('reading', EDGY_READING));

package/dist/view.js

@@ -1,4 +1,4 @@
-import { QualityNudgeExtension, SpotlightHostExtension, ValidationProfileExtension, ValidationRuleExtension, validationToolbarConfig, } from '@formicoidea/labre-core/blocks/surface';
+import { QualityNudgeExtension, ReadingProfileExtension, SpotlightHostExtension, ValidationProfileExtension, ValidationRuleExtension, validationToolbarConfig, } from '@formicoidea/labre-core/blocks/surface';
 import { ToolbarModuleExtension } from '@formicoidea/labre-core/shared/services';
 import { ViewExtensionProvider, } from '@formicoidea/labre-core/ext-loader';
 import { extendTemplateCategory } from '@formicoidea/labre-core/gfx/template';
@@ -8,6 +8,7 @@ import { edgyCommandIcons, edgyCommands } from './commands.js';
 import { effects } from './effects.js';
 import { EDGY_NUDGES } from './nudges.js';
 import { EDGY_PROFILES } from './profiles.js';
+import { EDGY_READING } from './reading.js';
 import { EdgyRelationResolver } from './relation-resolver.js';
 import { EDGY_ROLES } from './roles.js';
 import { EDGY_RULES } from './rules.js';
@@ -114,6 +115,13 @@ export class EdgyViewExtension extends ViewExtensionProvider {
             // the renderers are always on); with the flag off nothing new is named
             // because nothing new is being armed. See `./relation-resolver.ts`.
             context.register(EdgyRelationResolver);
+            // The reversed reading (MF3): what the board says about an element, on
+            // demand. One declaration — the roles and the relation edge, both already
+            // stated elsewhere in this framework — is the whole of what makes the
+            // generic engine able to read an EDGY board. The CLICK that triggers it is
+            // registered once by the surface and gated by the presence of this
+            // profile, so it goes with the flag without either side naming the other.
+            context.register(ReadingProfileExtension(EDGY_READING));
             context.register(edgySeniorTool);
             // The eight EDGY commands: the sub-menu renders them, Settings ›
             // Shortcuts finally lists them, and a host override on an id binds.

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@formicoidea/labre-framework-edgy",
   "description": "Labre edgy framework for @formicoidea/labre-core.",
-  "version": "0.35.0",
+  "version": "0.37.0",
   "type": "module",
   "sideEffects": false,
   "author": "lajola",
@@ -31,8 +31,8 @@
     "dist"
   ],
   "dependencies": {
-    "@formicoidea/labre-core": "0.35.0",
-    "@formicoidea/labre-ddd-shared": "0.35.0",
+    "@formicoidea/labre-core": "0.37.0",
+    "@formicoidea/labre-ddd-shared": "0.37.0",
     "@preact/signals-core": "^1.8.0",
     "lit": "^3.2.0",
     "yjs": "^13.6.21"