@sdlcworks/components 0.0.21 → 0.0.23

package/dist/index.d.ts

@@ -20,103 +20,96 @@ export declare enum DeploymentArtifactType {
 	container_image = "container_image"
 }
 /**
- * Abstract base class for defining connection interfaces.
- * Users extend this class to define the schema for data that
- * connecting components must provide.
+ * Transforms any interface name to canonical hyphen-separated lowercase form.
+ *
+ * @example
+ * toCanonicalInterfaceName("ServiceAccount") // "service-account"
+ * toCanonicalInterfaceName("service_account") // "service-account"
+ * toCanonicalInterfaceName("SERVICE-ACCOUNT") // "service-account"
+ * toCanonicalInterfaceName("serviceAccountCI") // "service-account-ci"
  */
-export declare abstract class ConnectionInterface<TSchema extends z.ZodObject<z.ZodRawShape> = z.ZodObject<z.ZodRawShape>> {
-	abstract readonly schema: TSchema;
-}
+export declare function toCanonicalInterfaceName(name: string): string;
+/**
+ * Connection interface definition with a unique name and typed schema.
+ * The name is used for matching interfaces across separately bundled components.
+ */
+export type ConnectionInterfaceDef<TName extends string = string, TSchema extends z.ZodObject<z.ZodRawShape> = z.ZodObject<z.ZodRawShape>> = {
+	readonly name: TName;
+	readonly schema: TSchema;
+};
 /**
- * Factory function to create a ConnectionInterface class from a schema.
- * Avoids boilerplate of defining a class manually.
+ * Creates a connection interface definition with a unique name and schema.
+ * The name is canonicalized to hyphen-separated lowercase and registered
+ * globally to detect collisions.
  *
  * @example
- * const TriggerConnection = createConnectionInterface(
- *   z.object({ eventSource: z.string() })
+ * const ServiceAccountCI = defineConnectionInterface(
+ *   "service-account",
+ *   z.object({ email: z.string() })
  * );
  */
-export declare function createConnectionInterface<TSchema extends z.ZodObject<z.ZodRawShape>>(schema: TSchema): {
-	new (): {
-		readonly schema: TSchema;
-	};
-};
+export declare function defineConnectionInterface<TName extends string, TSchema extends z.ZodObject<z.ZodRawShape>>(name: TName, schema: TSchema): ConnectionInterfaceDef<TName, TSchema>;
 /**
- * Extends a ConnectionInterface class with additional schema fields.
- * The resulting class merges the parent and child schemas.
+ * Merges a parent interface's schema with additional fields.
+ * Use with defineConnectionInterface to create extended interfaces.
  *
  * @example
- * const BaseCI = createConnectionInterface(
- *   z.object({ foo: z.string() })
- * );
- * const ExtendedCI = extendConnectionInterface(
- *   BaseCI,
- *   z.object({ bar: z.number() })
+ * const ExtendedCI = defineConnectionInterface(
+ *   "extended-service",
+ *   extendSchema(BaseCI, z.object({ extraField: z.string() }))
  * );
- * // ExtendedCI schema: { foo: string, bar: number }
  */
-export declare function extendConnectionInterface<TParentSchema extends z.ZodObject<z.ZodRawShape>, TChildSchema extends z.ZodObject<z.ZodRawShape>>(parentClass: ConnectionInterfaceClass<TParentSchema>, additionalSchema: TChildSchema): {
-	new (): {
-		readonly schema: z.ZodObject<((string | number) & keyof TChildSchema["shape"] extends never ? Readonly<{
-			[k: string]: z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
-		}> & TChildSchema["shape"] : (Readonly<{
-			[k: string]: z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
-		}> extends infer T_1 extends z.core.util.SomeObject ? {
-			[K in keyof T_1 as K extends keyof TChildSchema["shape"] ? never : K]: T_1[K];
-		} : never) & (TChildSchema["shape"] extends infer T_2 extends z.core.util.SomeObject ? {
-			[K_1 in keyof T_2]: T_2[K_1];
-		} : never)) extends infer T ? {
-			[k in keyof T]: T[k];
-		} : never, TChildSchema["_zod"]["config"]>;
-	};
-};
+export declare function extendSchema<TParentSchema extends z.ZodObject<z.ZodRawShape>, TChildSchema extends z.ZodObject<z.ZodRawShape>>(parentDef: ConnectionInterfaceDef<string, TParentSchema>, additionalSchema: TChildSchema): z.ZodObject<((string | number) & keyof TChildSchema["shape"] extends never ? Readonly<{
+	[k: string]: z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+}> & TChildSchema["shape"] : (Readonly<{
+	[k: string]: z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+}> extends infer T_1 extends z.core.util.SomeObject ? {
+	[K in keyof T_1 as K extends keyof TChildSchema["shape"] ? never : K]: T_1[K];
+} : never) & (TChildSchema["shape"] extends infer T_2 extends z.core.util.SomeObject ? {
+	[K_1 in keyof T_2]: T_2[K_1];
+} : never)) extends infer T ? {
+	[k in keyof T]: T[k];
+} : never, TChildSchema["_zod"]["config"]>;
 /**
  * TCP Connection Interface - defines a TCP-based connection endpoint.
  * Use this for components that expose TCP services.
  */
-export declare const TCPCI: {
-	new (): {
-		readonly schema: z.ZodObject<{
-			url: z.ZodObject<{
-				type: z.ZodEnum<typeof TCPUrlType>;
-				value: z.ZodString;
-			}, z.core.$strip>;
-			publicAccess: z.ZodBoolean;
-		}, z.core.$strip>;
-	};
-};
-/**
- * Type alias for ConnectionInterface class constructors.
- */
-export type ConnectionInterfaceClass<TSchema extends z.ZodObject<z.ZodRawShape> = z.ZodObject<z.ZodRawShape>> = new () => ConnectionInterface<TSchema>;
+export declare const TCPCI: ConnectionInterfaceDef<"tcp", z.ZodObject<{
+	url: z.ZodObject<{
+		type: z.ZodEnum<typeof TCPUrlType>;
+		value: z.ZodString;
+	}, z.core.$strip>;
+	publicAccess: z.ZodBoolean;
+}, z.core.$strip>>;
 /**
- * Extract the inferred data type from a ConnectionInterface class.
+ * Extract the inferred data type from a ConnectionInterfaceDef.
  */
-export type InferConnectionData<C extends ConnectionInterfaceClass> = z.infer<InstanceType<C>["schema"]>;
+export type InferConnectionData<D extends ConnectionInterfaceDef> = z.infer<D["schema"]>;
 /**
  * Wrap connection data with PulumiInput to support Pulumi Output types.
  */
-export type InferConnectionDataWithInputs<C extends ConnectionInterfaceClass> = {
-	[K in keyof InferConnectionData<C>]: PulumiInput<InferConnectionData<C>[K]>;
-};
+export type InferConnectionDataWithInputs<D extends ConnectionInterfaceDef> = InferConnectionData<D> extends infer Data ? {
+	[K in keyof Data]: PulumiInput<Data[K]>;
+} : never;
 /**
  * Entry type for declareConnectionInterfaces parameter.
  * Declares an interface that this component exposes with typed data.
  */
-export type DeclaredConnectionInterfaceEntry<C extends ConnectionInterfaceClass = ConnectionInterfaceClass> = {
-	interface: C;
-	data: InferConnectionDataWithInputs<C>;
+export type DeclaredConnectionInterfaceEntry<D extends ConnectionInterfaceDef = ConnectionInterfaceDef> = {
+	interface: D;
+	data: InferConnectionDataWithInputs<D>;
 };
 /**
  * Function type for declareConnectionInterfaces.
  * Called within pulumi function to declare exposed connection interfaces.
  */
-export type DeclareConnectionInterfacesFn = <C extends ConnectionInterfaceClass>(entries: DeclaredConnectionInterfaceEntry<C>[]) => void;
+export type DeclareConnectionInterfacesFn = <D extends ConnectionInterfaceDef>(entries: DeclaredConnectionInterfaceEntry<D>[]) => void;
+export type InferredZodObject<S extends z.ZodRawShape> = z.infer<z.ZodObject<S>>;
 export type InferZodType<S extends z.ZodRawShape> = {
-	[K in keyof z.infer<z.ZodObject<S>>]: PulumiInput<z.infer<z.ZodObject<S>>[K]>;
+	[K in keyof InferredZodObject<S>]: PulumiInput<InferredZodObject<S>[K]>;
 };
 export type InferOutputType<OShape extends z.ZodRawShape> = {
-	[K in keyof z.infer<z.ZodObject<OShape>>]: PulumiOutput<z.infer<z.ZodObject<OShape>>[K]>;
+	[K in keyof InferredZodObject<OShape>]: PulumiOutput<InferredZodObject<OShape>[K]>;
 };
 declare const emptyOutputSchema: z.ZodObject<{}, z.core.$strip>;
 export type EmptyOutputShape = typeof emptyOutputSchema.shape;
@@ -155,7 +148,6 @@ export type InfraComponentOpts<CShape extends z.ZodRawShape, DShape extends z.Zo
 	outputSchema: z.ZodObject<OShape>;
 	connectionTypes: ConnTypes;
 };
-export type InfraComponentInputs<C> = C;
 export type ArtifactInfo = {
 	artifact: {
 		uri: string;
@@ -192,26 +184,25 @@ export type ConnectionHandlerCtx<S, ConnectorData, ConnectionType extends string
 };
 /**
  * Result returned by connection handlers.
- * Can return:
- * - A record mapping component names to their URIs
- * - A single URI string
- * - void if no URIs need to be returned
+ * Must return a record mapping component names to their URIs.
  */
-export type ConnectionHandlerResult = Record<string, PulumiOutput<string>> | PulumiOutput<string> | void;
+export type ConnectionHandlerResult = Record<string, PulumiOutput<string>>;
 /**
- * A connection handler entry mapping a ConnectionInterface to its handler function.
+ * A connection handler entry mapping a ConnectionInterfaceDef to its handler function.
  */
-export type ConnectionHandlerEntry<S, ConnectionType extends string, C extends ConnectionInterfaceClass> = {
-	interface: C;
-	handler: (ctx: ConnectionHandlerCtx<S, InferConnectionData<C>, ConnectionType>) => Promise<ConnectionHandlerResult>;
+export type ConnectionHandlerEntry<S, ConnectionType extends string, D extends ConnectionInterfaceDef> = {
+	interface: D;
+	handler: (ctx: ConnectionHandlerCtx<S, InferConnectionData<D>, ConnectionType>) => Promise<ConnectionHandlerResult>;
 };
-export declare function connectionHandler<C extends ConnectionInterfaceClass>(entry: {
-	interface: C;
-	handler: (ctx: ConnectionHandlerCtx<any, InferConnectionData<C>, any>) => Promise<ConnectionHandlerResult>;
-}): {
-	interface: C;
-	handler: (ctx: ConnectionHandlerCtx<any, InferConnectionData<C>, any>) => Promise<ConnectionHandlerResult>;
+/**
+ * Type definition for a connection handler entry.
+ * Simplifies by not duplicating the type in return position.
+ */
+export type ConnectionHandlerDef<D extends ConnectionInterfaceDef> = {
+	interface: D;
+	handler: (ctx: ConnectionHandlerCtx<any, InferConnectionData<D>, any>) => Promise<ConnectionHandlerResult>;
 };
+export declare function connectionHandler<D extends ConnectionInterfaceDef>(entry: ConnectionHandlerDef<D>): ConnectionHandlerDef<D>;
 export type ProviderDeployCtx<D, S> = {
 	state: S;
 } & Record<string, DeploymentInfo>;
@@ -244,23 +235,24 @@ export type ProviderDeallocateFn<S> = (ctx: ProviderDeallocateCtx<S>) => Promise
 export type ProviderUpsertArtifactsFn<S> = (ctx: ProviderUpsertArtifactsCtx<S>) => Promise<void>;
 declare const emptyStateSchema: z.ZodObject<{}, z.core.$strip>;
 export type EmptyStateShape = typeof emptyStateSchema.shape;
-export type ProviderFnsDef<I, D, O, SShape extends z.ZodRawShape = EmptyStateShape, ConnectionType extends string = string> = {
+export type InferredState<SShape extends z.ZodRawShape> = z.infer<z.ZodObject<SShape>>;
+export type ProviderFnsDef<I, D, O, SShape extends z.ZodRawShape = EmptyStateShape, ConnectionType extends string = string, S = InferredState<SShape>> = {
 	stateSchema?: z.ZodObject<SShape>;
-	initialState?: z.infer<z.ZodObject<SShape>>;
-	pulumi: ProviderPulumiFn<I, z.infer<z.ZodObject<SShape>>, O>;
-	connect?: readonly ConnectionHandlerEntry<z.infer<z.ZodObject<SShape>>, ConnectionType, any>[];
-	deploy?: ProviderDeployFn<D, z.infer<z.ZodObject<SShape>>>;
-	allocateComponent?: ProviderAllocateFn<z.infer<z.ZodObject<SShape>>>;
-	deallocateComponent?: ProviderDeallocateFn<z.infer<z.ZodObject<SShape>>>;
-	upsertArtifacts?: ProviderUpsertArtifactsFn<z.infer<z.ZodObject<SShape>>>;
+	initialState?: S;
+	pulumi: ProviderPulumiFn<I, S, O>;
+	connect?: readonly ConnectionHandlerEntry<S, ConnectionType, any>[];
+	deploy?: ProviderDeployFn<D, S>;
+	allocateComponent?: ProviderAllocateFn<S>;
+	deallocateComponent?: ProviderDeallocateFn<S>;
+	upsertArtifacts?: ProviderUpsertArtifactsFn<S>;
 };
 /**
- * Stored version of ConnectionHandlerEntry that preserves ConnectionInterfaceClass type.
- * This ensures `interface` is always typed as ConnectionInterfaceClass (not any)
+ * Stored version of ConnectionHandlerEntry that preserves ConnectionInterfaceDef type.
+ * This ensures `interface` is always typed as ConnectionInterfaceDef (not any)
  * when accessing from the registry, allowing runtime schema access.
  */
 export type StoredConnectionHandlerEntry = {
-	interface: ConnectionInterfaceClass;
+	interface: ConnectionInterfaceDef;
 	handler: (ctx: ConnectionHandlerCtx<any, any, any>) => Promise<ConnectionHandlerResult>;
 };
 export type StoredProviderFns = {
@@ -274,7 +266,14 @@ export type StoredProviderFns = {
 	upsertArtifacts?: ProviderUpsertArtifactsFn<any>;
 };
 export type ProviderRegistry = Partial<Record<CloudProvider, StoredProviderFns>>;
-export type DeclaredConnectionInterfaces = Map<ConnectionInterfaceClass, any>;
+/**
+ * Map of interface name to its schema and declared data.
+ * Keyed by canonical interface name for cross-bundle matching.
+ */
+export type DeclaredConnectionInterfaces = Map<string, {
+	schema: z.ZodObject<z.ZodRawShape>;
+	data: any;
+}>;
 export declare class InfraComponent<CShape extends z.ZodRawShape, DShape extends z.ZodRawShape, OShape extends z.ZodRawShape = EmptyOutputShape, ConnTypes extends Record<string, {
 	description: string;
 }> = Record<string, {
@@ -286,12 +285,12 @@ export declare class InfraComponent<CShape extends z.ZodRawShape, DShape extends
 	validationDeploymentInputSchema: z.ZodTypeAny;
 	private declaredConnectionInterfaces;
 	constructor(opts: InfraComponentOpts<CShape, DShape, OShape, ConnTypes>);
-	implement<SShape extends z.ZodRawShape = EmptyStateShape>(provider: CloudProvider, fns: ProviderFnsDef<InfraComponentInputs<InferZodType<CShape>>, InferZodType<DShape>, InferOutputType<OShape>, SShape, keyof ConnTypes & string>): this;
+	implement<SShape extends z.ZodRawShape = EmptyStateShape>(provider: CloudProvider, fns: ProviderFnsDef<InferZodType<CShape>, InferZodType<DShape>, InferOutputType<OShape>, SShape, keyof ConnTypes & string>): this;
 	/**
 	 * Get the schema for a specific connection interface.
 	 * Used by the orchestrator at runtime.
 	 */
-	getConnectionSchema(interfaceClass: ConnectionInterfaceClass): z.ZodObject<z.ZodRawShape> | undefined;
+	getConnectionSchema(interfaceDef: ConnectionInterfaceDef): z.ZodObject<z.ZodRawShape>;
 	/**
 	 * Create the declareConnectionInterfaces function for use in pulumi context.
 	 * The orchestrator calls this before invoking the pulumi function.

package/dist/index.js

@@ -1,138 +1 @@
-// src/infra.ts
-import { z } from "zod";
-import * as pulumi from "@pulumi/pulumi";
-var CloudProvider;
-((CloudProvider2) => {
-  CloudProvider2["aws"] = "aws";
-  CloudProvider2["gcloud"] = "gcloud";
-  CloudProvider2["azure"] = "azure";
-  CloudProvider2["linode"] = "linode";
-  CloudProvider2["hetzner"] = "hetzner";
-  CloudProvider2["cloudflare"] = "cloudflare";
-})(CloudProvider ||= {});
-var TCPUrlType;
-((TCPUrlType2) => {
-  TCPUrlType2["ipv4"] = "ipv4";
-  TCPUrlType2["ipv6"] = "ipv6";
-  TCPUrlType2["domain"] = "domain";
-})(TCPUrlType ||= {});
-var DeploymentArtifactType;
-((DeploymentArtifactType2) => {
-  DeploymentArtifactType2["container_image"] = "container_image";
-})(DeploymentArtifactType ||= {});
-
-class ConnectionInterface {
-}
-function createConnectionInterface(schema) {
-  return class extends ConnectionInterface {
-    schema = schema;
-  };
-}
-function extendConnectionInterface(parentClass, additionalSchema) {
-  const parentInstance = new parentClass;
-  const mergedSchema = parentInstance.schema.merge(additionalSchema);
-  return class extends ConnectionInterface {
-    schema = mergedSchema;
-  };
-}
-var TCPCI = createConnectionInterface(z.object({
-  url: z.object({
-    type: z.nativeEnum(TCPUrlType),
-    value: z.string()
-  }),
-  publicAccess: z.boolean()
-}));
-var emptyOutputSchema = z.object({});
-function transformSchemaToAcceptOutputs(schema) {
-  if (schema instanceof z.ZodObject) {
-    const shape = schema.shape;
-    const newShape = {};
-    for (const key in shape) {
-      newShape[key] = transformSchemaToAcceptOutputs(shape[key]);
-    }
-    return z.object(newShape);
-  }
-  if (schema instanceof z.ZodOptional) {
-    return transformSchemaToAcceptOutputs(schema.unwrap()).optional();
-  }
-  if (schema instanceof z.ZodNullable) {
-    return transformSchemaToAcceptOutputs(schema.unwrap()).nullable();
-  }
-  if (schema instanceof z.ZodArray) {
-    return z.array(transformSchemaToAcceptOutputs(schema.element));
-  }
-  return z.union([
-    schema,
-    z.custom((val) => pulumi.Output.isInstance(val))
-  ]);
-}
-var InfraComponentOptsSchema = z.object({
-  metadata: z.object({
-    stateful: z.boolean(),
-    proxiable: z.boolean()
-  }),
-  connectionTypes: z.record(z.string(), z.object({
-    description: z.string().min(5)
-  })),
-  configSchema: z.custom(),
-  deploymentInputSchema: z.custom(),
-  outputSchema: z.custom()
-});
-function connectionHandler(entry) {
-  return entry;
-}
-var emptyStateSchema = z.object({});
-
-class InfraComponent {
-  opts;
-  providers;
-  validationSchema;
-  validationDeploymentInputSchema;
-  declaredConnectionInterfaces = new Map;
-  constructor(opts) {
-    this.opts = InfraComponentOptsSchema.parse(opts);
-    this.providers = {};
-    this.validationSchema = transformSchemaToAcceptOutputs(opts.configSchema);
-    this.validationDeploymentInputSchema = transformSchemaToAcceptOutputs(opts.deploymentInputSchema);
-  }
-  implement(provider, fns) {
-    this.providers[provider] = {
-      ...fns,
-      stateSchema: fns.stateSchema ?? emptyStateSchema,
-      initialState: fns.initialState
-    };
-    return this;
-  }
-  getConnectionSchema(interfaceClass) {
-    const instance = new interfaceClass;
-    return instance.schema;
-  }
-  createDeclareConnectionInterfacesFn() {
-    return (entries) => {
-      for (const entry of entries) {
-        const instance = new entry.interface;
-        const schema = instance.schema;
-        const transformedSchema = transformSchemaToAcceptOutputs(schema);
-        const parseResult = transformedSchema.safeParse(entry.data);
-        if (!parseResult.success) {
-          throw new Error(`Invalid data for connection interface ${entry.interface.name}: ${parseResult.error.message}`);
-        }
-        this.declaredConnectionInterfaces.set(entry.interface, entry.data);
-      }
-    };
-  }
-  getDeclaredInterfaces() {
-    return this.declaredConnectionInterfaces;
-  }
-}
-export {
-  extendConnectionInterface,
-  createConnectionInterface,
-  connectionHandler,
-  TCPUrlType,
-  TCPCI,
-  InfraComponent,
-  DeploymentArtifactType,
-  ConnectionInterface,
-  CloudProvider
-};
+import{z as q}from"zod";import*as L from"@pulumi/pulumi";var Q;((H)=>{H.aws="aws";H.gcloud="gcloud";H.azure="azure";H.linode="linode";H.hetzner="hetzner";H.cloudflare="cloudflare"})(Q||={});var M;((E)=>{E.ipv4="ipv4";E.ipv6="ipv6";E.domain="domain"})(M||={});var V;((j)=>j.container_image="container_image")(V||={});var K=new Map;function W(b){return b.replace(/([a-z])([A-Z])/g,"$1-$2").replace(/[_\s]+/g,"-").toLowerCase().replace(/-+/g,"-").replace(/^-|-$/g,"")}function X(b){let j=W(b);if(j.length===0)throw new Error("Connection interface name cannot be empty");let B=K.get(j);if(B!==void 0&&B!==b)throw new Error(`Connection interface name collision: '${b}' resolves to '${j}' which is already registered by '${B}'`);return K.set(j,b),j}function Y(b,j){return{name:X(b),schema:j}}function k(b,j){return b.schema.merge(j)}var x=Y("tcp",q.object({url:q.object({type:q.nativeEnum(M),value:q.string()}),publicAccess:q.boolean()})),N=q.object({});function F(b){if(b instanceof q.ZodObject){let j=b.shape,B={};for(let E in j)B[E]=F(j[E]);return q.object(B)}if(b instanceof q.ZodOptional)return F(b.unwrap()).optional();if(b instanceof q.ZodNullable)return F(b.unwrap()).nullable();if(b instanceof q.ZodArray)return q.array(F(b.element));return q.union([b,q.custom((j)=>L.Output.isInstance(j))])}var Z=q.object({metadata:q.object({stateful:q.boolean(),proxiable:q.boolean()}),connectionTypes:q.record(q.string(),q.object({description:q.string().min(5)})),configSchema:q.custom(),deploymentInputSchema:q.custom(),outputSchema:q.custom()});function w(b){return b}var _=q.object({});class ${opts;providers;validationSchema;validationDeploymentInputSchema;declaredConnectionInterfaces=new Map;constructor(b){this.opts=Z.parse(b),this.providers={},this.validationSchema=F(b.configSchema),this.validationDeploymentInputSchema=F(b.deploymentInputSchema)}implement(b,j){return this.providers[b]={...j,stateSchema:j.stateSchema??_,initialState:j.initialState},this}getConnectionSchema(b){return b.schema}createDeclareConnectionInterfacesFn(){return(b)=>{for(let j of b){let B=j.interface.schema,J=F(B).safeParse(j.data);if(!J.success)throw new Error(`Invalid data for connection interface '${j.interface.name}': ${J.error.message}`);this.declaredConnectionInterfaces.set(j.interface.name,{schema:j.interface.schema,data:j.data})}}}getDeclaredInterfaces(){return this.declaredConnectionInterfaces}}export{W as toCanonicalInterfaceName,k as extendSchema,Y as defineConnectionInterface,w as connectionHandler,M as TCPUrlType,x as TCPCI,$ as InfraComponent,V as DeploymentArtifactType,Q as CloudProvider};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sdlcworks/components",
-  "version": "0.0.21",
+  "version": "0.0.23",
   "module": "dist/index.js",
   "files": [
     "dist"