@cratis/scene.engine 4.15.0 → 4.17.0

package/editing/resolveEffectiveConfiguration.ts

@@ -162,6 +162,17 @@ export function resolveEffectiveConfiguration(
             }
         }
 
+        const maximumItems = grant.descriptor.constraints?.maximumItems;
+        if (isCollection && maximumItems !== undefined && items.length > maximumItems) {
+            // Saved items that no longer fit - the owner lowered the limit after they were added - are left out of
+            // the result in order and kept in the saved data, like any other saved value that no longer fits.
+            const dropped = items.splice(maximumItems);
+            diagnostics.push(errorDiagnostic(
+                DiagnosticCode.ContributionTypeMismatch,
+                `'${grant.path}' on '${grant.component}' allows at most ${maximumItems} items; ${dropped.map(item => `'${item.id}'`).join(', ')} ${dropped.length === 1 ? 'is' : 'are'} ignored and kept.`,
+                { instance: current.contributedBy ?? owner.instance, component: grant.component, path: grant.path }));
+        }
+
         if (isCollection) {
             current.items = items;
             current.inheritedValue = baseItems.map(toFlatItem);

package/editing/validateValue.ts

@@ -1,7 +1,7 @@
 // Copyright (c) Cratis. All rights reserved.
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
-import { CollectionItemDescriptor, PropertyDescriptor, PropertyValueType } from '@cratis/scene.model';
+import { BindingSourceKind, CollectionItemDescriptor, PropertyDescriptor, PropertyValueType } from '@cratis/scene.model';
 
 function isRecord(value: unknown): value is Record<string, unknown> {
     return value !== null && typeof value === 'object' && !Array.isArray(value);
@@ -24,6 +24,13 @@ export function validateValue(descriptor: PropertyDescriptor, value: unknown): s
         return constraints.required ? 'a value is required' : undefined;
     }
 
+    const binding = bindingKindOf(value);
+    if (binding !== undefined && descriptor.acceptedBindingKinds !== undefined) {
+        return descriptor.acceptedBindingKinds.includes(binding.kind)
+            ? undefined
+            : `a ${binding.kind} binding is not accepted here; use ${descriptor.acceptedBindingKinds.join(' or ')}`;
+    }
+
     switch (descriptor.valueType) {
         case PropertyValueType.String: {
             if (typeof value !== 'string') return 'expected a string';
@@ -77,6 +84,19 @@ export function validateValue(descriptor: PropertyDescriptor, value: unknown): s
  * The deepest nesting a JSON value may have. Authored configuration (chart datasets, option lists) is shallow;
  * the limit turns a runaway or hostile structure into a validation message instead of a stack overflow.
  */
+const bindingKinds = new Set<string>(Object.values(BindingSourceKind));
+
+/**
+ * The source kind of a value that is a typed binding expression - an object with a known `kind` and a
+ * string `path` - rather than a value of the property's own type. Only consulted for properties that declare
+ * `acceptedBindingKinds`, so a collection property such as a command form's `inputs` can be bound to a
+ * table's `selectedItem` instead of listing its items.
+ */
+function bindingKindOf(value: unknown): { kind: BindingSourceKind } | undefined {
+    if (!isRecord(value) || typeof value.kind !== 'string' || !bindingKinds.has(value.kind) || typeof value.path !== 'string') return undefined;
+    return { kind: value.kind as BindingSourceKind };
+}
+
 const maximumJsonDepth = 64;
 
 /**

package/index.ts

@@ -7,6 +7,7 @@ export * from './BindingScope';
 export * from './BindingDiagnostic';
 export * from './resolveBindingExpression';
 export * from './nestBindingScope';
+export * from './resolveArgumentSource';
 export * from './removeComponentOutputs';
 export * from './QueryBindingState';
 export * from './QueryBindingTicket';

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@cratis/scene.engine",
-    "version": "4.15.0",
+    "version": "4.17.0",
     "description": "The Scene runtime: walks a Scene element tree and drives whichever renderer is plugged in. Does not know React, or any other rendering platform, exists.",
     "keywords": [
         "cratis",
@@ -48,9 +48,9 @@
         "up": "yarn g:up"
     },
     "dependencies": {
-        "@cratis/scene.model": "4.15.0"
+        "@cratis/scene.model": "4.17.0"
     },
     "devDependencies": {
-        "@cratis/scene.model": "4.15.0"
+        "@cratis/scene.model": "4.17.0"
     }
 }

package/resolveArgumentSource.ts

@@ -0,0 +1,33 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { BindingSourceKind } from '@cratis/scene.model';
+import { BindingScope } from './BindingScope';
+import { resolveBindingExpression } from './resolveBindingExpression';
+
+/** The prefix of an argument source that reads another element's output. */
+export const componentArgumentSourcePrefix = 'component.';
+
+/**
+ * Resolves where a command argument comes from, as an action's argument mapping writes it.
+ *
+ * `component.<id>.<output>` reads an output another element publishes - an input's `value`, a table's
+ * `selectedItem.id` - from the same output scope a `componentProperty` binding reads. Element ids may contain
+ * dots, so the longest id with outputs in scope wins: `component.order.lines.value` reads `value` of
+ * `order.lines` when that element exists. Any other source is a path in the data context. An empty source,
+ * or an element with no outputs in scope, resolves as absent.
+ *
+ * The C# engine (`ArgumentSources.Resolve`) behaves identically; both run `argument-source-fixtures.json`.
+ */
+export function resolveArgumentSource(source: string, scope: BindingScope): unknown {
+    if (!source) return undefined;
+    if (!source.startsWith(componentArgumentSourcePrefix)) return resolveBindingExpression({ path: source }, scope);
+
+    const reference = source.substring(componentArgumentSourcePrefix.length);
+    const componentId = Object.keys(scope.componentOutputs ?? {})
+        .filter(id => reference === id || reference.startsWith(`${id}.`))
+        .sort((left, right) => right.length - left.length)[0];
+    if (componentId === undefined) return undefined;
+
+    return resolveBindingExpression({ kind: BindingSourceKind.ComponentProperty, componentId, path: reference.substring(componentId.length + 1) }, scope);
+}