@syncbridge/common 2.2.0 → 2.3.1

package/app-factory.js

@@ -266,7 +266,13 @@ export var AppFactory;
             }
         });
     }
-    function _patchValues(ctx, instance, target, valPath, newValues, newVariables, oldValues, oldVariables) {
+    /**
+     * A running element's values, patched with a new profile's: its hot-plug
+     * settings alone - those of a hot-plug group all of them. A list - of
+     * values or of groups - is replaced whole, never merged into an object.
+     * The paths changed are kept for its 'values-updated' event.
+     */
+    function _patchValues(ctx, instance, target, valPath, newValues, newVariables, oldValues, oldVariables, hot = false) {
         if (oldValues)
             Object.assign(target, oldValues);
         const updatedValues = ctx.valueUpdates?.get(instance) || [];
@@ -274,17 +280,20 @@ export var AppFactory;
         if (newVariables) {
             for (const [varKey, varMeta] of Object.entries(newVariables)) {
                 const keyPath = valPath ? valPath + '.' + varKey : varKey;
-                /** Update only hotplug variables */
-                if (varMeta?.hotPlug !== true)
+                /** Update only hotplug variables, and all of a hotplug group */
+                if (!hot && varMeta?.hotPlug !== true)
                     continue;
-                if (varMeta.type === 'nested') {
+                if (varMeta.type === 'nested' && !varMeta.isArray) {
                     target[varKey] = {};
-                    _patchValues(ctx, instance, target[varKey], keyPath, newValues[varKey], newVariables[varKey]?.variables || {}, oldValues?.[varKey], oldVariables?.[varKey]?.variables);
+                    _patchValues(ctx, instance, target[varKey], keyPath, newValues?.[varKey], newVariables[varKey]?.variables || {}, oldValues?.[varKey], oldVariables?.[varKey]?.variables, true);
                     continue;
                 }
-                if (!equal(target[varKey], newValues[varKey])) {
+                const value = newValues?.[varKey];
+                if (!equal(target[varKey], value)) {
                     updatedValues.push(keyPath);
-                    target[varKey] = newValues[varKey];
+                    /* Its own copy: the profile's left as it is */
+                    target[varKey] =
+                        value && typeof value === 'object' ? clone(value) : value;
                 }
             }
         }

package/constants.d.ts

@@ -1,4 +1,4 @@
-export declare const version = "2.2.0";
+export declare const version = "2.3.1";
 export declare const CLASS_METADATA: unique symbol;
 export declare const CLASS_TYPE: unique symbol;
 export declare const VARIABLE_CONTAINER: unique symbol;

package/constants.js

@@ -1,4 +1,4 @@
-export const version = '2.2.0';
+export const version = '2.3.1';
 export const CLASS_METADATA = Symbol.for('CLASS_METADATA');
 export const CLASS_TYPE = Symbol.for('CLASS_TYPE');
 export const VARIABLE_CONTAINER = Symbol.for('VARIABLE_CONTAINER');

package/host-link/host-packages.d.ts

@@ -23,3 +23,47 @@ export interface HostPackagePlanItem {
 export interface HostPackagesResolveResponse {
     items: HostPackagePlanItem[];
 }
+/** Where, under Console's API, a host's packages' updates are asked */
+export declare const HOST_PACKAGE_UPDATES_PATH = "host/packages/updates";
+/** What a host asks of its packages' updates */
+export interface HostPackageUpdatesRequest {
+    /**
+     * check: what is newer of the versions it has; download: grants to read
+     * the versions it installs
+     */
+    mode: 'check' | 'download';
+    /** "@org/name" -> its newest version installed (check), or the one it installs (download) */
+    packages: Record<string, string>;
+}
+/** A version offered: what it needs of the registry's packages */
+export interface HostPackageOffer {
+    version: string;
+    /** Registry packages it depends on: name -> range */
+    dependencies: Record<string, string>;
+}
+/** What is newer of a package, or why it was not told */
+export interface HostPackageUpdate {
+    name: string;
+    /** The version sent */
+    version: string;
+    /**
+     * NOT_FOUND: not in the registry, or (download) no such version;
+     * NO_ACCESS: the host's workspace may not use it; SUSPENDED (download):
+     * the version is suspended
+     */
+    problem?: 'NOT_FOUND' | 'NO_ACCESS' | 'SUSPENDED';
+    /** check: the newest of its minor, newer than the one sent (a fix) */
+    patch?: HostPackageOffer;
+    /** check: the newest of its major, newer than the one sent */
+    minor?: HostPackageOffer;
+    /** check: a newer major's newest - told, never installed without asking */
+    major?: string;
+    /** download: the version sent, its grant in its link; a few minutes good */
+    download?: HostPackagePlanItem & {
+        dependencies: Record<string, string>;
+    };
+}
+/** Each package sent, answered */
+export interface HostPackageUpdatesResponse {
+    items: HostPackageUpdate[];
+}

package/host-link/host-packages.js

@@ -7,3 +7,15 @@
  */
 /** Where, under Console's API, a host's packages are planned */
 export const HOST_PACKAGES_PATH = 'host/packages';
+/*
+ * A host's packages' updates: what the registry has newer of each package
+ * it has, asked in one call. To check, its installed versions sent - each
+ * answered the newest of its minor (a fix), of its major (fixes and
+ * features) and a newer major, told apart; nothing signed. To install, the
+ * very versions it takes sent - each answered with a short-lived grant to
+ * read it: read by it without its access asked again, unless that version,
+ * its package or the host's workspace is suspended, or the access ended,
+ * since.
+ */
+/** Where, under Console's API, a host's packages' updates are asked */
+export const HOST_PACKAGE_UPDATES_PATH = 'host/packages/updates';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@syncbridge/common",
-  "version": "2.2.0",
+  "version": "2.3.1",
   "description": "SyncBridge Common utilities",
   "author": "Panates Inc",
   "license": "MIT",