@highstate/contract 0.4.3 → 0.4.5

package/dist/index.d.ts

@@ -1,30 +1,102 @@
-import { TString, TNumber, TBoolean, TArray, TUnion, TLiteral, TRecordOrObject, TAny, Static, TSchema, TAnySchema, TObject, TOptional } from '@sinclair/typebox';
+import { Static, TString, TNumber, TBoolean, TArray, TUnion, TLiteral, TRecordOrObject, TAny, TSchema, TAnySchema, TOptional, TObject } from '@sinclair/typebox';
 export { Static, Type } from '@sinclair/typebox';
 
+declare const InstanceType: unique symbol;
 type InstanceInput<TType extends string = string> = {
-    type: TType;
+    [InstanceType]?: TType;
     instanceId: string;
     output: string;
 };
-type InstanceInputMap = Record<string, InstanceInput | InstanceInput[]>;
-type BaseInstanceModel = {
+type HubInput = {
+    hubId: string;
+};
+type Position = {
+    x: number;
+    y: number;
+};
+type InstanceModel = {
+    /**
+     * The id of the instance unique within the project.
+     *
+     * The format is `${instanceType}:${instanceName}`.
+     */
     id: string;
+    /**
+     * The type of the instance.
+     */
     type: string;
+    /**
+     * The name of the instance.
+     *
+     * Must be unique within instances of the same type in the project.
+     */
     name: string;
+    /**
+     * The static arguments passed to the instance.
+     */
+    args?: Record<string, unknown>;
+    /**
+     * The direct instances passed as inputs to the instance.
+     */
+    inputs?: Record<string, InstanceInput[]>;
+    /**
+     * The inputs passed to the instance from the hubs.
+     *
+     * Only for designer-first instances.
+     */
+    hubInputs?: Record<string, HubInput[]>;
+    /**
+     * The inputs injected to the instance from the hubs.
+     *
+     * While `hubInputs` allows to pass hubs to distinct inputs,
+     * `injectionInputs` allows to pass hubs to the instance as a whole filling all inputs with matching types.
+     *
+     * Only for designer-first instances.
+     */
+    injectionInputs?: HubInput[];
+    /**
+     * The position of the instance on the canvas.
+     *
+     * Only for designer-first instances.
+     */
+    position?: Position;
+    /**
+     * The id of the parent instance.
+     *
+     * Only for child instances of the composite instances.
+     */
     parentId?: string;
-    args: Record<string, unknown>;
-    inputs: InstanceInputMap;
-    outputs?: InstanceInputMap;
+    /**
+     * The direct instance inputs which instance returns as outputs.
+     *
+     * Only for computed composite instances.
+     */
+    outputs?: Record<string, InstanceInput[]>;
 };
+/**
+ * Formats the instance id from the instance type and instance name.
+ *
+ * @param instanceType The type of the instance.
+ * @param instanceName The name of the instance.
+ *
+ * @returns The formatted instance id.
+ */
 declare function getInstanceId(instanceType: string, instanceName: string): string;
-declare function parseInstanceId(key: string): [string, string];
+/**
+ * Parses the instance id into the instance type and instance name.
+ *
+ * @param instanceId The instance id to parse.
+ *
+ * @returns The instance type and instance name.
+ */
+declare function parseInstanceId(instanceId: string): [instanceType: string, instanceName: string];
 
 type CompositeInstance = {
-    instance: BaseInstanceModel;
-    children: BaseInstanceModel[];
+    instance: InstanceModel;
+    children: InstanceModel[];
 };
 declare function resetEvaluation(): void;
-declare function getInstances(): readonly BaseInstanceModel[];
+declare function getInstances(): readonly InstanceModel[];
 declare function getCompositeInstances(): readonly CompositeInstance[];
 
 type ArgumentValueSchema = TString | TNumber | TBoolean | TArray<TString> | TArray<TNumber> | TUnion<TLiteral[]> | TRecordOrObject<TString, TAny> | TArray;
@@ -50,6 +122,7 @@ type Meta = {
 };
 
 type PartialKeys<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
+type RequiredKeys<T, K extends keyof T> = Omit<T, K> & Required<Pick<T, K>>;
 type ListRequiredKeys<T extends Record<string, unknown>> = T extends Record<string, never> ? never : {
     [K in keyof T]-?: undefined extends T[K] ? never : K;
 }[keyof T];
@@ -73,12 +146,19 @@ type OptionalUndefinedFields<T extends Record<string, unknown>> = {
     [K in Exclude<keyof T, PickUndefinedKeys<T>>]: T[K];
 };
 /**
- * Removes the indentation from a multiline string.
+ * Formats a multiline string and trims the indentation.
  *
  * @param str The string to trim.
  * @returns The trimmed string.
  */
 declare function text(array: TemplateStringsArray, ...values: unknown[]): string;
+/**
+ * Removes the indentation from a multiline string.
+ *
+ * @param text The text to trim.
+ * @returns The trimmed text.
+ */
+declare function trimIndentation(text: string): string;
 
 /**
  * The entity is some abstract object which can be passed from one component to another through their inputs and outputs.
@@ -94,16 +174,12 @@ type Entity<TType extends string = string, TEntitySchema extends TSchema = TSche
      * The JSON schema of the entity value.
      */
     schema: TEntitySchema;
-    /**
-     * Whether the content of the entity is sensitive and should be hidden from the UI.
-     */
-    sensitive: boolean;
     /**
      * The extra metadata of the entity.
      */
     meta: Meta;
 };
-type EntityOptions<TType extends string, TSchema extends TAnySchema> = PartialKeys<Entity<TType, TSchema>, "sensitive" | "meta">;
+type EntityOptions<TType extends string, TSchema extends TAnySchema> = PartialKeys<Entity<TType, TSchema>, "meta">;
 declare function defineEntity<TType extends string, TSchema extends TAnySchema>(options: EntityOptions<TType, TSchema>): Entity<TType, TSchema>;
 declare function isEntity(value: unknown): value is Entity;
 
@@ -218,7 +294,7 @@ declare function defineComponent<TArgs extends Record<string, ComponentArgumentO
 declare function isComponent(value: unknown): value is Component;
 
 type UnitOptions<TArgs extends Record<string, ComponentArgumentOptions>, TInputs extends Record<string, ComponentInputOptions>, TOutputs extends Record<string, ComponentInputOptions>, TSecrets extends Record<string, ComponentArgumentOptions>> = Omit<ComponentOptions<TArgs, TInputs, TOutputs>, "create"> & {
-    source: UnitSource;
+    source?: UnitSource;
     secrets?: TSecrets;
 };
 type UnitSource = {
@@ -247,4 +323,4 @@ type Unit<TArgs extends Record<string, ArgumentValue> = Record<string, never>, T
 declare function isUnitModel(model: ComponentModel): model is UnitModel;
 declare function defineUnit<TArgs extends Record<string, ComponentArgumentOptions> = Record<string, never>, TInputs extends Record<string, ComponentInputOptions> = Record<string, never>, TOutputs extends Record<string, ComponentInputOptions> = Record<string, never>, TSecrets extends Record<string, ComponentArgumentOptions> = Record<string, never>>(options: UnitOptions<TArgs, TInputs, TOutputs, TSecrets>): Unit<ArgumentOptionsMapToStatic<TArgs>, ComponentInputOptionsMapToSpecMap<TInputs>, ComponentInputOptionsMapToSpecMap<TOutputs>, ArgumentOptionsMapToStatic<TSecrets>>;
 
-export { type ArgumentValue, type ArgumentValueSchema, type BaseInstanceModel, type Component, type ComponentArgument, type ComponentInput, type ComponentInputSpec, type ComponentMeta, type ComponentModel, type CompositeInstance, type Entity, type InstanceInput, type InstanceInputMap, type Unit, type UnitModel, type UnitSource, defineComponent, defineEntity, defineUnit, getCompositeInstances, getInstanceId, getInstances, isComponent, isEntity, isUnitModel, parseInstanceId, resetEvaluation, text };
+export { type ArgumentValue, type ArgumentValueSchema, type Component, type ComponentArgument, type ComponentInput, type ComponentInputSpec, type ComponentMeta, type ComponentModel, type CompositeInstance, type Entity, type HubInput, type InstanceInput, type InstanceModel, type PartialKeys, type Position, type RequiredKeys, type Unit, type UnitModel, type UnitSource, defineComponent, defineEntity, defineUnit, getCompositeInstances, getInstanceId, getInstances, isComponent, isEntity, isUnitModel, parseInstanceId, resetEvaluation, text, trimIndentation };

package/dist/index.mjs

@@ -1,14 +1,14 @@
 import { OptionalKind } from '@sinclair/typebox';
 export { Type } from '@sinclair/typebox';
-import { mapValues } from 'remeda';
+import { mapValues, pickBy, isNonNullish } from 'remeda';
 
 function getInstanceId(instanceType, instanceName) {
   return `${instanceType}:${instanceName}`;
 }
-function parseInstanceId(key) {
-  const parts = key.split(":");
+function parseInstanceId(instanceId) {
+  const parts = instanceId.split(":");
   if (parts.length !== 2) {
-    throw new Error(`Invalid instance key: ${key}`);
+    throw new Error(`Invalid instance key: ${instanceId}`);
   }
   return parts;
 }
@@ -51,13 +51,29 @@ function registerInstance(instance, fn) {
 
 function defineEntity(options) {
   return {
-    sensitive: false,
     meta: {},
     ...options
   };
 }
 function isEntity(value) {
-  return typeof value === "object" && value !== null && "type" in value && "schema" in value && "sensitive" in value && "meta" in value;
+  return typeof value === "object" && value !== null && "type" in value && "schema" in value && "meta" in value;
+}
+
+function text(array, ...values) {
+  const str = array.reduce(
+    // eslint-disable-next-line @typescript-eslint/no-base-to-string
+    (result, part, i) => result + part + (values[i] ? String(values[i]) : ""),
+    ""
+  );
+  return trimIndentation(str);
+}
+function trimIndentation(text2) {
+  const lines = text2.split("\n");
+  const indent = lines.filter((line) => line.trim() !== "").map((line) => line.match(/^\s*/)?.[0].length ?? 0).reduce((min, indent2) => Math.min(min, indent2), Infinity);
+  return lines.map((line) => line.slice(indent)).join("\n").trim();
+}
+function mapItemOrArray(item, fn) {
+  return Array.isArray(item) ? item.map(fn) : fn(item);
 }
 
 function defineComponent(options) {
@@ -73,22 +89,17 @@ function defineComponent(options) {
         inputs: inputs ?? {}
       },
       () => {
+        const parentInputs = mapValues(pickBy(inputs ?? {}, isNonNullish), (value, key) => {
+          return mapItemOrArray(value, () => ({ instanceId: id, output: key }));
+        });
         const outputs = options.create({
           id,
           name,
           args: args ?? {},
-          inputs: mapValues(inputs ?? {}, (value, key) => {
-            if (Array.isArray(value)) {
-              return value.map((x) => substituteInstanceInput(id, x, key));
-            }
-            return substituteInstanceInput(id, value, key);
-          })
+          inputs: parentInputs
         }) ?? {};
         const substitutedOutputs = mapValues(outputs, (value, key) => {
-          if (Array.isArray(value)) {
-            return value.map((x) => substituteInstanceInput(id, x, key));
-          }
-          return substituteInstanceInput(id, value, key);
+          return mapItemOrArray(value, () => ({ instanceId: id, output: key }));
         });
         return [substitutedOutputs, outputs];
       }
@@ -105,13 +116,6 @@ function defineComponent(options) {
   };
   return create;
 }
-function substituteInstanceInput(instanceId, input, outputKey) {
-  return {
-    type: input.type,
-    instanceId,
-    output: outputKey
-  };
-}
 function isComponent(value) {
   return typeof value === "function" && "model" in value;
 }
@@ -176,9 +180,8 @@ function defineUnit(options) {
 function fillUnitOutputs(instanceId, optionsOutputs = {}) {
   const outputs = {};
   for (const key in optionsOutputs) {
-    const entity = "entity" in optionsOutputs[key] ? optionsOutputs[key].entity : optionsOutputs[key];
     outputs[key] = {
-      type: entity.type,
+      kind: "instance",
       instanceId,
       output: key
     };
@@ -186,11 +189,4 @@ function fillUnitOutputs(instanceId, optionsOutputs = {}) {
   return outputs;
 }
 
-function text(array, ...values) {
-  const str = array.reduce((result, part, i) => result + part + (String(values[i]) || ""), "");
-  const lines = str.split("\n");
-  const indent = lines.filter((line) => line.trim() !== "").map((line) => line.match(/^\s*/)?.[0].length ?? 0).reduce((min, indent2) => Math.min(min, indent2), Infinity);
-  return lines.map((line) => line.slice(indent)).join("\n").trim();
-}
-
-export { defineComponent, defineEntity, defineUnit, getCompositeInstances, getInstanceId, getInstances, isComponent, isEntity, isUnitModel, parseInstanceId, resetEvaluation, text };
+export { defineComponent, defineEntity, defineUnit, getCompositeInstances, getInstanceId, getInstances, isComponent, isEntity, isUnitModel, parseInstanceId, resetEvaluation, text, trimIndentation };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@highstate/contract",
-  "version": "0.4.3",
+  "version": "0.4.5",
   "type": "module",
   "module": "dist/index.mjs",
   "types": "dist/index.d.ts",
@@ -22,12 +22,12 @@
   },
   "dependencies": {
     "@sinclair/typebox": "^0.34.11",
-    "remeda": "^2.17.4"
+    "remeda": "^2.21.0"
   },
   "devDependencies": {
     "@vitest/coverage-v8": "2.1.8",
     "pkgroll": "^2.5.1",
     "vitest": "^2.1.8"
   },
-  "gitHead": "5b99600bd04872a4817c97b26501e1f22c8a0780"
+  "gitHead": "61f6f1b0ff3f97bd7ed5e37c26302f094b892392"
 }