@croct/plug 0.11.5 → 0.12.0

package/constants.d.ts

@@ -2,4 +2,4 @@ export declare const CDN_URL = "https://cdn.croct.io/js/v1/lib/plug.js";
 export declare const PLAYGROUND_ORIGIN = "https://play.croct.com";
 export declare const PLAYGROUND_CONNECT_URL = "https://play.croct.com/connect.html";
 export declare const PREVIEW_WIDGET_ORIGIN = "https://cdn.croct.io";
-export declare const PREVIEW_WIDGET_URL = "https://cdn.croct.io/js/v1/lib/plug/widget-0.11.5.html";
+export declare const PREVIEW_WIDGET_URL = "https://cdn.croct.io/js/v1/lib/plug/widget-0.12.0.html";

package/constants.js

@@ -5,5 +5,5 @@ exports.CDN_URL = 'https://cdn.croct.io/js/v1/lib/plug.js';
 exports.PLAYGROUND_ORIGIN = 'https://play.croct.com';
 exports.PLAYGROUND_CONNECT_URL = 'https://play.croct.com/connect.html';
 exports.PREVIEW_WIDGET_ORIGIN = 'https://cdn.croct.io';
-exports.PREVIEW_WIDGET_URL = 'https://cdn.croct.io/js/v1/lib/plug/widget-0.11.5.html';
+exports.PREVIEW_WIDGET_URL = 'https://cdn.croct.io/js/v1/lib/plug/widget-0.12.0.html';
 //# sourceMappingURL=constants.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@croct/plug",
-  "version": "0.11.5",
+  "version": "0.12.0",
   "description": "A fully-featured devkit for building natively personalized applications.",
   "license": "MIT",
   "author": {
@@ -33,8 +33,8 @@
     "bundle": "rollup -c"
   },
   "dependencies": {
-    "@croct/json": "^1.1.0",
-    "@croct/sdk": "^0.12.2",
+    "@croct/json": "^2.0.1",
+    "@croct/sdk": "^0.12.3",
     "tslib": "^2.2.0"
   },
   "devDependencies": {
@@ -42,8 +42,8 @@
     "@rollup/plugin-commonjs": "^24.0.0",
     "@rollup/plugin-node-resolve": "^15.0.1",
     "@rollup/plugin-replace": "^5.0.1",
-    "@rollup/plugin-terser": "^0.3.0",
-    "@rollup/plugin-typescript": "^10.0.0",
+    "@rollup/plugin-terser": "^0.4.0",
+    "@rollup/plugin-typescript": "^11.0.0",
     "@types/jest": "^29.2.2",
     "@typescript-eslint/parser": "^5.30.0",
     "eslint": "^8.27.0",
@@ -51,7 +51,8 @@
     "jest-environment-jsdom": "^29.3.1",
     "rollup": "^3.3.0",
     "ts-jest": "^29.0.3",
-    "typescript": "^4.9.3"
+    "ts-node": "^10.9.1",
+    "typescript": "^4.9.5"
   },
   "browserslist": [
     "last 1 version"

package/slot.d.ts

@@ -10,21 +10,31 @@ type LatestSlotVersionMap = {
 };
 export interface VersionedSlotMap extends LatestSlotVersionMap {
 }
+/**
+ * Creates an intersection of the given types distributing over unions.
+ *
+ * The difference between this type and the built-in `&` operator is that the
+ * `&` operator creates an intersection of the union members instead of
+ * creating a union of the intersection members. For example, given the types
+ * `Left = A | B` and `Right = C`, the type `Left & Right` expands to
+ * `(A | B) & C`, but `Merge<Left, Right>` expands to `A & C | B & C`,
+ * which improves type inference when narrowing the type.
+ */
+type Intersection<T, E> = T extends infer O ? O & E : never;
+type UnionContent = {
+    [K in ComponentVersionId]: Intersection<ComponentContent<K>, {
+        _component: K | null;
+    }>;
+};
+type UnknownContent = UnionContent[ComponentVersionId] extends never ? (JsonObject & {
+    _component: string | null;
+}) : UnionContent[ComponentVersionId];
+type VersionedContent<I extends VersionedSlotId> = Versioned<I, VersionedSlotMap, UnknownContent>;
+export type DynamicSlotId = any;
 export type SlotId = keyof VersionedSlotMap extends never ? string : keyof VersionedSlotMap;
 export type SlotVersion<I extends SlotId = SlotId> = Version<VersionedSlotMap, I>;
 export type SlotVersionId<I extends SlotId = SlotId> = CanonicalVersionId<I, VersionedSlotMap>;
 export type VersionedSlotId<I extends SlotId = SlotId> = VersionedId<I, VersionedSlotMap>;
-export type DynamicSlotId = any;
-type DiscriminatedContent<T = Record<never, never>, I extends string | null = null> = T & {
-    _component: I;
-};
-type DiscriminatedComponentMap = {
-    [K in ComponentVersionId]: DiscriminatedContent<ComponentContent<K>, K>;
-};
-export type CompatibleSlotContent<T extends ComponentVersionId = ComponentVersionId> = DiscriminatedComponentMap[T];
-type UnionContent = {
-    [I in ComponentVersionId]: DiscriminatedComponentMap[I];
-}[ComponentVersionId];
-type UnknownContent = UnionContent extends never ? JsonObject : UnionContent | DiscriminatedContent;
-export type SlotContent<I extends VersionedSlotId = VersionedSlotId, C extends JsonObject = JsonObject> = JsonObject extends C ? string extends I ? UnknownContent : DiscriminatedContent<Versioned<I, VersionedSlotMap, UnknownContent>, string> : C;
+export type CompatibleSlotContent<T extends ComponentVersionId = ComponentVersionId> = UnionContent[T];
+export type SlotContent<I extends VersionedSlotId = VersionedSlotId, C extends JsonObject = JsonObject> = JsonObject extends C ? (string extends I ? UnknownContent : VersionedContent<I>) : C;
 export {};

package/src/slot.ts

@@ -10,32 +10,39 @@ type LatestSlotVersionMap = {[K in keyof SlotMap]: {latest: SlotMap[K]}};
 export interface VersionedSlotMap extends LatestSlotVersionMap {
 }
 
-export type SlotId = keyof VersionedSlotMap extends never ? string : keyof VersionedSlotMap;
-
-export type SlotVersion<I extends SlotId = SlotId> = Version<VersionedSlotMap, I>;
+/**
+ * Creates an intersection of the given types distributing over unions.
+ *
+ * The difference between this type and the built-in `&` operator is that the
+ * `&` operator creates an intersection of the union members instead of
+ * creating a union of the intersection members. For example, given the types
+ * `Left = A | B` and `Right = C`, the type `Left & Right` expands to
+ * `(A | B) & C`, but `Merge<Left, Right>` expands to `A & C | B & C`,
+ * which improves type inference when narrowing the type.
+ */
+type Intersection<T, E> = T extends infer O ? O & E : never;
+
+type UnionContent = {
+    [K in ComponentVersionId]: Intersection<ComponentContent<K>, {_component: K | null}>;
+};
 
-export type SlotVersionId<I extends SlotId = SlotId> = CanonicalVersionId<I, VersionedSlotMap>;
+type UnknownContent = UnionContent[ComponentVersionId] extends never
+    ? (JsonObject & {_component: string | null})
+    : UnionContent[ComponentVersionId];
 
-export type VersionedSlotId<I extends SlotId = SlotId> = VersionedId<I, VersionedSlotMap>;
+type VersionedContent<I extends VersionedSlotId> = Versioned<I, VersionedSlotMap, UnknownContent>;
 
 export type DynamicSlotId = any;
 
-type DiscriminatedContent<T = Record<never, never>, I extends string|null = null> = T & {_component: I};
+export type SlotId = keyof VersionedSlotMap extends never ? string : keyof VersionedSlotMap;
 
-type DiscriminatedComponentMap = {
-    [K in ComponentVersionId]: DiscriminatedContent<ComponentContent<K>, K>;
-};
+export type SlotVersion<I extends SlotId = SlotId> = Version<VersionedSlotMap, I>;
 
-export type CompatibleSlotContent<T extends ComponentVersionId = ComponentVersionId> =
-    DiscriminatedComponentMap[T];
+export type SlotVersionId<I extends SlotId = SlotId> = CanonicalVersionId<I, VersionedSlotMap>;
 
-type UnionContent = {[I in ComponentVersionId]: DiscriminatedComponentMap[I]}[ComponentVersionId];
+export type VersionedSlotId<I extends SlotId = SlotId> = VersionedId<I, VersionedSlotMap>;
 
-type UnknownContent = UnionContent extends never ? JsonObject : UnionContent | DiscriminatedContent;
+export type CompatibleSlotContent<T extends ComponentVersionId = ComponentVersionId> = UnionContent[T];
 
 export type SlotContent<I extends VersionedSlotId = VersionedSlotId, C extends JsonObject = JsonObject> =
-    JsonObject extends C
-        ? string extends I
-            ? UnknownContent
-            : DiscriminatedContent<Versioned<I, VersionedSlotMap, UnknownContent>, string>
-        : C;
+    JsonObject extends C ? (string extends I ? UnknownContent : VersionedContent<I>) : C;

package/src/versioning.ts

@@ -10,9 +10,14 @@ export type CanonicalVersionId<I extends string, M> = {
     [K in I]: `${K}@${Extract<Version<M, K>, `${number}`>}`
 }[I];
 
-export type VersionedId<I extends string, M> = I | {[K in I]: `${K}@${Version<M, K> & string}`}[I];
+/**
+ * Utility type that coerces any type to a string if it is not a string literal.
+ */
+type CastString<T extends string> = T extends `${infer V}` ? V : string;
 
-export type ExtractId<I extends string> = I extends `${infer V}@${string}` ? V : I;
+export type VersionedId<I extends string, M> = CastString<I> | {[K in I]: `${K}@${Version<M, K> & string}`}[I];
+
+export type ExtractId<I extends string> = I extends `${infer V}@${string}` ? V : CastString<I>;
 
 export type Version<M, I extends string> = LatestAlias | (I extends keyof M ? keyof M[I] : never);
 

package/versioning.d.ts

@@ -4,9 +4,14 @@ export type ExtractVersion<I extends string> = I extends `${string}@${infer V}`
 export type CanonicalVersionId<I extends string, M> = {
     [K in I]: `${K}@${Extract<Version<M, K>, `${number}`>}`;
 }[I];
-export type VersionedId<I extends string, M> = I | {
+/**
+ * Utility type that coerces any type to a string if it is not a string literal.
+ */
+type CastString<T extends string> = T extends `${infer V}` ? V : string;
+export type VersionedId<I extends string, M> = CastString<I> | {
     [K in I]: `${K}@${Version<M, K> & string}`;
 }[I];
-export type ExtractId<I extends string> = I extends `${infer V}@${string}` ? V : I;
+export type ExtractId<I extends string> = I extends `${infer V}@${string}` ? V : CastString<I>;
 export type Version<M, I extends string> = LatestAlias | (I extends keyof M ? keyof M[I] : never);
 export type Versioned<I extends string, M, C extends JsonObject = JsonObject> = ExtractId<I> extends keyof M ? ExtractVersion<I> extends keyof M[ExtractId<I>] ? M[ExtractId<I>][ExtractVersion<I>] : C : C;
+export {};