@syncbridge/common 2.3.0 → 2.4.0

package/README.md

@@ -110,6 +110,19 @@ A component may use components too, with `Component.UseComponent`. A URI
 can name another module's component, for example
 `@syncbridge/net:TcpClient`. Declare that module as a peer as well.
 
+A slot may take one of several kinds that share no interface - a device
+reached as a client or as a server - with `oneOf`, each a class or its
+URI. Required, one of them must be chosen, and only one can be:
+
+```ts
+@App.UseComponent({ oneOf: [HL7Client, HL7Server], required: true })
+declare readonly hl7: HL7Client | HL7Server;
+```
+
+The app tells which it was given (`this.hl7 instanceof HL7Server`). Where
+the kinds do share what the app uses, an abstract base they both extend
+serves better: one slot typed by it, no branching.
+
 ## Variables
 
 `@DefineVariable` describes a setting. Its type is read from the

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.3.0";
+export declare const version = "2.4.0";
 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.3.0';
+export const version = '2.4.0';
 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/decorators/use-component.decorator.d.ts

@@ -5,7 +5,14 @@ import { ComponentBase } from '../classes/component-base.js';
 import { ElementComponentMetadata } from '../models/index.js';
 export declare function UseComponent<T extends AppBase | ComponentBase>(options?: UseComponent.Options): (target: T, propertyKey: string | symbol) => void;
 export declare namespace UseComponent {
-    interface Options extends Partial<StrictOmit<ElementComponentMetadata, 'classUri' | 'interfaceUri'>> {
+    interface Options extends Partial<StrictOmit<ElementComponentMetadata, 'classUri' | 'interfaceUri' | 'oneOf'>> {
         uri?: string;
+        /**
+         * A slot taking a class of one of these, not of one interface alone:
+         * `oneOf: [HL7Client, HL7Server]` - its property typed as either
+         */
+        oneOf?: (string | {
+            uri: string;
+        })[];
     }
 }

package/decorators/use-component.decorator.js

@@ -10,7 +10,14 @@ export function UseComponent(options = {}) {
         /** c8 ignore next */
         if (typeof propertyKey !== 'string')
             throw new TypeError('Property key must be a string');
-        let uri = options.uri;
+        /* One of several: each a class, or its uri */
+        const oneOf = options.oneOf?.map(c => {
+            const u = typeof c === 'string' ? c : c?.uri;
+            if (!u)
+                throw new TypeError(`${String(propertyKey)}: oneOf takes components - classes with @Component, or their uris`);
+            return u;
+        });
+        let uri = options.uri ?? oneOf?.[0];
         if (!uri) {
             const designType = Reflect.getMetadata('design:type', target, propertyKey);
             if (typeof designType === 'function' && designType.uri) {
@@ -21,7 +28,8 @@ export function UseComponent(options = {}) {
         metadata.components = metadata.components || {};
         metadata.components[propertyKey] = {
             interfaceUri: uri,
-            ...omit(options, ['classUri', 'interfaceUri']),
+            ...omit(options, ['classUri', 'interfaceUri', 'oneOf']),
+            ...(oneOf?.length ? { oneOf } : {}),
             propertyKey,
         };
     };

package/index.d.ts

@@ -36,6 +36,7 @@ export { SECRET_PREFIX, secretDecryptor, secretEncryptor, } from './utils/encryp
 export * from './utils/materialize-metadata.js';
 export * from './utils/normalize-metadata.js';
 export * from './utils/registry-names.js';
+export * from './utils/slot-interfaces.js';
 export * from './utils/type-guards.js';
 export * from './utils/uri-to-id.js';
 export * from './utils/worker-permissions.js';

package/index.js

@@ -36,6 +36,7 @@ export { SECRET_PREFIX, secretDecryptor, secretEncryptor, } from './utils/encryp
 export * from './utils/materialize-metadata.js';
 export * from './utils/normalize-metadata.js';
 export * from './utils/registry-names.js';
+export * from './utils/slot-interfaces.js';
 export * from './utils/type-guards.js';
 export * from './utils/uri-to-id.js';
 export * from './utils/worker-permissions.js';

package/models/enums/plugin-permission.enum.d.ts

@@ -0,0 +1,19 @@
+/**
+ * What a plugin reaches beyond its own data directory, its settings, its
+ * status, questions and actions, as it declares it needs: shown to the
+ * server's admins, given once they approve it. Not declared, none.
+ */
+export declare enum PluginPermission {
+    /** `host.workers.addEnvironment`: what every worker starts with */
+    WorkerEnvironment = "worker-environment",
+    /** `host.logs.registerTarget`: every log record, the workers' messages among them */
+    LogRecords = "log-records",
+    /** `host.workers.list/get` and the workers' events: their ids, names, statuses */
+    Workers = "workers",
+    /** The network: the hosts it reaches named in `hosts` */
+    Network = "network",
+    /** Starting other programs, outside Node's permission model */
+    ChildProcesses = "child-processes",
+    /** Native addons (.node), outside Node's permission model */
+    NativeCode = "native-code"
+}

package/models/enums/plugin-permission.enum.js

@@ -0,0 +1,33 @@
+import { EnumType } from '@opra/common';
+/**
+ * What a plugin reaches beyond its own data directory, its settings, its
+ * status, questions and actions, as it declares it needs: shown to the
+ * server's admins, given once they approve it. Not declared, none.
+ */
+export var PluginPermission;
+(function (PluginPermission) {
+    /** `host.workers.addEnvironment`: what every worker starts with */
+    PluginPermission["WorkerEnvironment"] = "worker-environment";
+    /** `host.logs.registerTarget`: every log record, the workers' messages among them */
+    PluginPermission["LogRecords"] = "log-records";
+    /** `host.workers.list/get` and the workers' events: their ids, names, statuses */
+    PluginPermission["Workers"] = "workers";
+    /** The network: the hosts it reaches named in `hosts` */
+    PluginPermission["Network"] = "network";
+    /** Starting other programs, outside Node's permission model */
+    PluginPermission["ChildProcesses"] = "child-processes";
+    /** Native addons (.node), outside Node's permission model */
+    PluginPermission["NativeCode"] = "native-code";
+})(PluginPermission || (PluginPermission = {}));
+EnumType(PluginPermission, {
+    name: 'PluginPermission',
+    description: 'What a plugin reaches beyond its own data directory, as it declares it needs and an admin approves it',
+    meanings: {
+        WorkerEnvironment: 'What every worker starts with: its environment',
+        LogRecords: "Every log record, the workers' messages among them - their data too",
+        Workers: 'The workers: their ids, names and statuses, and their events',
+        Network: 'The network, the hosts it names',
+        ChildProcesses: "Starting other programs, outside Node's permission model",
+        NativeCode: "Native addons (.node), outside Node's permission model",
+    },
+});

package/models/index.d.ts

@@ -1,6 +1,7 @@
 export * from './enums/enum-source.enum.js';
 export * from './enums/log-channel-kind.js';
 export * from './enums/log-level.js';
+export * from './enums/plugin-permission.enum.js';
 export * from './enums/service-status.js';
 export * from './enums/variable-format.enum.js';
 export * from './enums/variable-type.enum.js';

package/models/index.js

@@ -1,6 +1,7 @@
 export * from './enums/enum-source.enum.js';
 export * from './enums/log-channel-kind.js';
 export * from './enums/log-level.js';
+export * from './enums/plugin-permission.enum.js';
 export * from './enums/service-status.js';
 export * from './enums/variable-format.enum.js';
 export * from './enums/variable-type.enum.js';

package/models/metadata/element-component-metadata.d.ts

@@ -12,6 +12,7 @@ export declare class ElementComponentMetadataRecord {
 export declare class ElementComponentMetadata {
     propertyKey?: string;
     interfaceUri: string;
+    oneOf?: string[];
     classUri?: string;
     version?: string;
     description?: string;

package/models/metadata/element-component-metadata.js

@@ -1,5 +1,5 @@
 import { __decorate, __metadata } from "tslib";
-import { ApiField, ComplexType } from '@opra/common';
+import { ApiField, ArrayType, ComplexType } from '@opra/common';
 import { LogChannelMetadataRecord } from './log-channel-metadata.js';
 import { VariableMetadataRecord } from './variable-metadata.js';
 /**
@@ -29,6 +29,14 @@ __decorate([
     }),
     __metadata("design:type", String)
 ], ElementComponentMetadata.prototype, "interfaceUri", void 0);
+__decorate([
+    ApiField({
+        label: 'One of',
+        description: 'The interfaces the assigned class may implement, one of them: a slot taking either of two kinds (an HL7 client or server). interfaceUri is the first of them, for what reads that alone',
+        type: ArrayType('string'),
+    }),
+    __metadata("design:type", Array)
+], ElementComponentMetadata.prototype, "oneOf", void 0);
 __decorate([
     ApiField({
         label: 'Interface URI',

package/models/metadata/plugin-metadata.d.ts

@@ -1,3 +1,4 @@
+import { PluginPermission } from '../enums/plugin-permission.enum.js';
 import { VariableMetadataRecord } from './variable-metadata.js';
 /**
  * A plugin as its class defines it (`@Plugin` of @syncbridge/plugin-api):
@@ -12,4 +13,6 @@ export declare class PluginMetadata {
     description?: string;
     readme?: string;
     settings?: VariableMetadataRecord;
+    permissions?: PluginPermission[];
+    hosts?: string[];
 }

package/models/metadata/plugin-metadata.js

@@ -1,5 +1,6 @@
 import { __decorate, __metadata } from "tslib";
-import { ApiField, ComplexType, StringType } from '@opra/common';
+import { ApiField, ArrayType, ComplexType, StringType } from '@opra/common';
+import { PluginPermission } from '../enums/plugin-permission.enum.js';
 import { VariableMetadataRecord } from './variable-metadata.js';
 /**
  * A plugin as its class defines it (`@Plugin` of @syncbridge/plugin-api):
@@ -58,6 +59,22 @@ __decorate([
     }),
     __metadata("design:type", VariableMetadataRecord)
 ], PluginMetadata.prototype, "settings", void 0);
+__decorate([
+    ApiField({
+        label: 'Permissions',
+        description: 'What it reaches beyond its own data directory: shown to the admins, given once they approve it',
+        type: ArrayType(PluginPermission),
+    }),
+    __metadata("design:type", Array)
+], PluginMetadata.prototype, "permissions", void 0);
+__decorate([
+    ApiField({
+        label: 'Hosts',
+        description: 'The hosts it reaches, with the network permission: shown and approved, not held yet',
+        type: ArrayType('string'),
+    }),
+    __metadata("design:type", Array)
+], PluginMetadata.prototype, "hosts", void 0);
 PluginMetadata = __decorate([
     ComplexType(),
     __metadata("design:paramtypes", [Object])

package/models/profile/profile-component.d.ts

@@ -17,6 +17,7 @@ export declare class ProfileComponentSettings {
  */
 export declare class ProfileComponent {
     uri: string;
+    writtenWith?: string;
     values?: Record<string, any>;
     components?: ProfileComponentRecord;
     settings?: ProfileComponentSettings;

package/models/profile/profile-component.js

@@ -47,6 +47,13 @@ __decorate([
     }),
     __metadata("design:type", String)
 ], ProfileComponent.prototype, "uri", void 0);
+__decorate([
+    ApiField({
+        label: 'Written with',
+        description: "The version of its component its values were last written with: the engine's to set, on every save - what a migration starts from",
+    }),
+    __metadata("design:type", String)
+], ProfileComponent.prototype, "writtenWith", void 0);
 __decorate([
     ApiField({
         label: 'Values',

package/models/profile/profile.d.ts

@@ -17,6 +17,7 @@ export declare class Profile {
     displayName: string;
     appUri: string;
     appVersion?: string;
+    writtenWith?: string;
     group?: string;
     description?: string;
     iconUrl?: string;

package/models/profile/profile.js

@@ -72,6 +72,13 @@ __decorate([
     }),
     __metadata("design:type", String)
 ], Profile.prototype, "appVersion", void 0);
+__decorate([
+    ApiField({
+        label: 'Written with',
+        description: "The version of its app its values were last written with: the engine's to set, on every save - what a migration starts from",
+    }),
+    __metadata("design:type", String)
+], Profile.prototype, "writtenWith", void 0);
 __decorate([
     ApiField({
         label: 'Group',

package/package.json

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

package/registry/docs-sidebar.d.ts

@@ -19,6 +19,13 @@ import type { LocalizedText } from './localized-text.js';
  * the sidebar is - its languages are found by its name (network.md for
  * network.tr.md). A title is text, or text by language. A document not
  * listed is read by a link to it alone.
+ *
+ * A module's sidebar may list documents beyond its directory, shared by
+ * the modules listing them: "../shared/setup.md". Listed by one, a
+ * document of no module's directory is that module's - not the package's
+ * own, unless the package's sidebar lists it too. A README.md it lists is
+ * its page, when it has none of its own; it lists one at most. The
+ * package's sidebar lists none of a module's directory.
  */
 export declare const SIDEBAR_FILE = "sidebar.json";
 /** Text, or text by language: { "tr": "Ağ", "en": "Network" } */

package/registry/docs-sidebar.js

@@ -1,5 +1,5 @@
 import { SbError } from '../classes/sb-error.js';
-import { CLASS_DIR_PATTERN, DOCS_DIR, isDocsLanguage } from './package-docs.js';
+import { CLASS_DIR_PATTERN, DOCS_DIR, isDocsLanguage, README_FILE, } from './package-docs.js';
 /**
  * How a package's documents are listed, where its author tells it: a
  * sidebar.json in docs/ (the package's own) or in docs/<ClassName>/ (an
@@ -20,6 +20,13 @@ import { CLASS_DIR_PATTERN, DOCS_DIR, isDocsLanguage } from './package-docs.js';
  * the sidebar is - its languages are found by its name (network.md for
  * network.tr.md). A title is text, or text by language. A document not
  * listed is read by a link to it alone.
+ *
+ * A module's sidebar may list documents beyond its directory, shared by
+ * the modules listing them: "../shared/setup.md". Listed by one, a
+ * document of no module's directory is that module's - not the package's
+ * own, unless the package's sidebar lists it too. A README.md it lists is
+ * its page, when it has none of its own; it lists one at most. The
+ * package's sidebar lists none of a module's directory.
  */
 export const SIDEBAR_FILE = 'sidebar.json';
 /** Categories within categories, at most */
@@ -75,8 +82,12 @@ export function parseSidebar(file, source, docs) {
                 parts.push(part);
         }
         const path = parts.join('/');
-        if (!path.startsWith(dir + '/') || (!owner && isModuleDoc(path))) {
-            errors.push(`${at}: "${name}" is not ${owner ? `${owner}'s` : "the package's own"} - a sidebar lists the documents beside it`);
+        if (!path.startsWith(DOCS_DIR + '/')) {
+            errors.push(`${at}: "${name}" goes out of ${DOCS_DIR}/ - a sidebar lists the package's documents`);
+            return;
+        }
+        if (!owner && isModuleDoc(path)) {
+            errors.push(`${at}: "${name}" is a module's - the package's sidebar lists its own documents`);
             return;
         }
         if (!docs.has(path)) {
@@ -145,6 +156,10 @@ export function parseSidebar(file, source, docs) {
             errors.push(`${file}: "${unknown.join('", "')}" is not read`);
         result = items(source.items, `${file}: items`, 0);
     }
+    /* A module's page: one README, its own or one it takes */
+    const readmes = [...listed].filter(p => p.endsWith('/' + README_FILE));
+    if (owner && readmes.length > 1)
+        errors.push(`${file}: ${readmes.join(', ')} - a module has one ${README_FILE}, its page: list one`);
     if (errors.length)
         throw new SbError(errors.join('\n'));
     return { items: result };

package/registry/extension-package.d.ts

@@ -26,7 +26,11 @@ export declare class ExtensionPackage {
     warnings: string[];
     /**
      * Takes the package's identity and dependencies from its `package.json`
-     * and its manifest (see readExtensionManifest)
+     * and its manifest (see readExtensionManifest).
+     *
+     * SyncBridge's modules (`@syncbridge/builtins`, ...) were once peers the
+     * host provided; a package that still declares one so depends on it as a
+     * registry package, as one built now does in its manifest.
      */
     assignManifest(pkgJson: ExtensionPackageJson, manifest?: SyncBridgeManifest): void;
 }

package/registry/extension-package.js

@@ -5,6 +5,7 @@ import { ComponentBase } from '../classes/component-base.js';
 import { SbError } from '../classes/sb-error.js';
 import { CLASS_TYPE } from '../constants.js';
 import { AppMetadata, ComponentMetadata, ElementMetadata, PluginMetadata, } from '../models/index.js';
+import { isSyncBridgeModule } from '../utils/registry-names.js';
 import { isAppBase, isComponentBase } from '../utils/type-guards.js';
 /**
  *
@@ -22,14 +23,23 @@ export class ExtensionPackage {
     warnings = [];
     /**
      * Takes the package's identity and dependencies from its `package.json`
-     * and its manifest (see readExtensionManifest)
+     * and its manifest (see readExtensionManifest).
+     *
+     * SyncBridge's modules (`@syncbridge/builtins`, ...) were once peers the
+     * host provided; a package that still declares one so depends on it as a
+     * registry package, as one built now does in its manifest.
      */
     assignManifest(pkgJson, manifest) {
         this.name = manifest?.name || pkgJson.name;
         this.version = pkgJson.version;
         this.description = pkgJson.description;
         this.registryDependencies = { ...manifest?.dependencies };
-        this.peerDependencies = { ...pkgJson.peerDependencies };
+        this.peerDependencies = {};
+        for (const [name, range] of Object.entries(pkgJson.peerDependencies || {}))
+            if (!isSyncBridgeModule(name))
+                this.peerDependencies[name] = range;
+            else
+                this.registryDependencies[name] ??= range;
     }
 }
 /**

package/utils/materialize-metadata.js

@@ -3,6 +3,7 @@ import { SbValidationError } from '../classes/sb-error.js';
 import { StackExecutor } from '../classes/stack-executor.js';
 import { AppMetadata, ElementComponentMetadata, ElementComponentMetadataRecord, Profile, ProfileComponent, VariableMetadata, VariableMetadataRecord, VariableType, } from '../models/index.js';
 import { ExtensionRegistry } from '../registry/extension-registry.js';
+import { slotInterfaces, slotTakes } from './slot-interfaces.js';
 /**
  * Materializes metadata from profile.
  */
@@ -78,6 +79,9 @@ function _materializeComponents(stackExecutor, srcMetadata, profile, options) {
                 }
                 materializedComponent = {
                     interfaceUri: metadataComponent.interfaceUri,
+                    ...(metadataComponent.oneOf
+                        ? { oneOf: metadataComponent.oneOf }
+                        : {}),
                     description: metadataComponent.description,
                     required: metadataComponent.required,
                 };
@@ -88,9 +92,8 @@ function _materializeComponents(stackExecutor, srcMetadata, profile, options) {
                 if (!profileComponent.uri)
                     throw new SbValidationError(`"uri" property required`);
                 const reg = ExtensionRegistry.getComponent(profileComponent.uri);
-                if (!(profileComponent.uri === metadataComponent.interfaceUri ||
-                    reg.metadata.interfaces?.includes(metadataComponent.interfaceUri)))
-                    throw new SbValidationError(`Selected component "${profileComponent.uri}" do not implement ${metadataComponent.interfaceUri}.`);
+                if (!slotTakes(metadataComponent, profileComponent.uri, reg.metadata.interfaces))
+                    throw new SbValidationError(`Selected component "${profileComponent.uri}" do not implement ${slotInterfaces(metadataComponent).join(' or ')}.`);
                 if (profileComponent.disabled && metadataComponent.required) {
                     throw new SbValidationError(`Component "${componentName}" is disabled but it is required.`);
                 }

package/utils/registry-names.d.ts

@@ -12,6 +12,19 @@ export declare const SBEXT_SCOPE = "sbext";
  * owner, while `@syncbridge/sqb` is still a valid registry name.
  */
 export declare const RESERVED_SCOPES: readonly string[];
+/** The SDK: on npm, not in the registry; the host provides them */
+export declare const SDK_PACKAGES: readonly string[];
+/** Whether a name is one of the SDK's packages, which come from npm */
+export declare const isSdkPackage: (name: string) => boolean;
+/**
+ * Whether a name is one of SyncBridge's own registry packages
+ * (`@syncbridge/builtins`, `@syncbridge/hl7`, ...). They are registry
+ * packages like any other - a server comes with a version of each, and
+ * installs a newer one a package needs from the registry - but a package
+ * imports one under its own name, `@syncbridge/builtins`, not
+ * `sb:@syncbridge/builtins`.
+ */
+export declare const isSyncBridgeModule: (name: string) => boolean;
 /**
  * Checks a registry organization name - the scope, with or without its `@`.
  * Returns the problems found; an empty array means it is valid.

package/utils/registry-names.js

@@ -13,6 +13,25 @@ export const SBEXT_SCOPE = 'sbext';
  * owner, while `@syncbridge/sqb` is still a valid registry name.
  */
 export const RESERVED_SCOPES = [SBEXT_SCOPE, 'syncbridge'];
+/** The SDK: on npm, not in the registry; the host provides them */
+export const SDK_PACKAGES = [
+    '@syncbridge/common',
+    '@syncbridge/runtime',
+    '@syncbridge/syncbuild',
+    '@syncbridge/testing',
+    '@syncbridge/plugin-api',
+];
+/** Whether a name is one of the SDK's packages, which come from npm */
+export const isSdkPackage = (name) => SDK_PACKAGES.includes(name);
+/**
+ * Whether a name is one of SyncBridge's own registry packages
+ * (`@syncbridge/builtins`, `@syncbridge/hl7`, ...). They are registry
+ * packages like any other - a server comes with a version of each, and
+ * installs a newer one a package needs from the registry - but a package
+ * imports one under its own name, `@syncbridge/builtins`, not
+ * `sb:@syncbridge/builtins`.
+ */
+export const isSyncBridgeModule = (name) => name.startsWith('@syncbridge/') && !isSdkPackage(name);
 /** npm's limit on the length of a whole package name, scope included */
 const MAX_NAME_LENGTH = 214;
 /** Lower-case, URL-safe, and not starting with `.` or `_` */

package/utils/slot-interfaces.d.ts

@@ -0,0 +1,10 @@
+import type { ElementComponentMetadata } from '../models/metadata/element-component-metadata.js';
+type Slot = Pick<ElementComponentMetadata, 'interfaceUri' | 'oneOf'>;
+/** The interfaces a slot takes a class of: its oneOf, else its interfaceUri */
+export declare function slotInterfaces(slot: Slot): string[];
+/**
+ * Whether a slot takes a class: one of its interfaces it is, or it
+ * implements (its metadata's interfaces)
+ */
+export declare function slotTakes(slot: Slot, uri: string, interfaces: readonly string[] | undefined): boolean;
+export {};

package/utils/slot-interfaces.js

@@ -0,0 +1,11 @@
+/** The interfaces a slot takes a class of: its oneOf, else its interfaceUri */
+export function slotInterfaces(slot) {
+    return slot.oneOf?.length ? slot.oneOf : [slot.interfaceUri];
+}
+/**
+ * Whether a slot takes a class: one of its interfaces it is, or it
+ * implements (its metadata's interfaces)
+ */
+export function slotTakes(slot, uri, interfaces) {
+    return slotInterfaces(slot).some(i => uri === i || !!interfaces?.includes(i));
+}