@ninetailed/experience.js-utils-contentful 2.0.0-beta.8 → 2.0.1

package/index.d.ts

@@ -0,0 +1,2 @@
+export * from './types';
+export { AudienceMapper, ExperienceMapper, isEntry, isAudienceEntry, isExperienceEntry, } from './lib';

package/index.esm.js

@@ -0,0 +1,211 @@
+import { z } from 'zod';
+
+const EntryLink = z.object({
+  type: z.literal('Link'),
+  linkType: z.string(),
+  id: z.string()
+});
+const Entry = z.object({
+  sys: z.object({
+    type: z.string(),
+    id: z.string(),
+    createdAt: z.string(),
+    updatedAt: z.string(),
+    locale: z.string(),
+    revision: z.number().optional(),
+    space: z.object({
+      sys: EntryLink.extend({
+        linkType: z.literal('Space')
+      })
+    }).optional(),
+    environment: z.object({
+      sys: EntryLink.extend({
+        linkType: z.literal('Environment')
+      })
+    }).optional(),
+    contentType: z.object({
+      sys: EntryLink.extend({
+        linkType: z.literal('ContentType')
+      })
+    })
+  }),
+  fields: z.object({}),
+  metadata: z.object({
+    tags: z.array(z.object({
+      sys: EntryLink.extend({
+        linkType: z.literal('Tag')
+      })
+    }))
+  })
+});
+
+const AudienceFields = z.object({
+  /**
+   * The name of the audience (Short Text)
+   */
+  nt_name: z.string(),
+
+  /**
+   * The internal id of the audience (Short Text)
+   */
+  nt_audience_id: z.string()
+});
+const AudienceEntry = Entry.extend({
+  fields: AudienceFields
+});
+
+const ExperienceFields = z.object({
+  /**
+   * The name of the experience (Short Text)
+   */
+  nt_name: z.string(),
+
+  /**
+   * The type if the experience (nt_experiment | nt_personalization)
+   */
+  nt_type: z.union([z.literal('nt_experiment'), z.literal('nt_personalization')]),
+
+  /**
+   * The config of the experience (JSON)
+   */
+  nt_config: z.object({
+    distribution: z.array(z.number()),
+    traffic: z.number(),
+    components: z.array(z.object({
+      baseline: z.object({
+        id: z.string()
+      }),
+      variants: z.array(z.object({
+        id: z.string(),
+        hidden: z.boolean()
+      }))
+    }))
+  }).optional().nullable(),
+
+  /**
+   * The audience of the experience (Audience)
+   */
+  nt_audience: AudienceEntry.optional().nullable(),
+
+  /**
+   * All used variants of the experience (Contentful references to other Content Types)
+   */
+  nt_variants: z.array(Entry).default([])
+});
+const ExperienceEntry = Entry.extend({
+  fields: ExperienceFields
+});
+
+class AudienceMapper {
+  static mapAudience(audience) {
+    return {
+      id: audience.sys.id
+    };
+  }
+
+}
+
+const isEntry = entry => {
+  try {
+    Entry.parse(entry);
+    return true;
+  } catch (error) {
+    return false;
+  }
+};
+
+const defaultMapVariant = (variant, {
+  hidden
+}) => Object.assign(Object.assign({}, variant), {
+  id: variant.sys.id,
+  hidden: hidden
+});
+
+class ExperienceMapper {
+  static mapExperience(entry, options) {
+    const _mapVariant = (options === null || options === void 0 ? void 0 : options.mapVariant) || defaultMapVariant;
+
+    const config = Object.assign({
+      traffic: 0,
+      distribution: [0.5, 0.5],
+      components: [{
+        baseline: {
+          id: ''
+        },
+        variants: [{
+          id: '',
+          hidden: false
+        }]
+      }]
+    }, entry.fields.nt_config);
+    const variantReferences = (entry.fields.nt_variants || []).filter(isEntry);
+    return Object.assign(Object.assign({
+      id: entry.sys.id,
+      type: entry.fields.nt_type
+    }, entry.fields.nt_audience ? {
+      audience: AudienceMapper.mapAudience(entry.fields.nt_audience)
+    } : {}), {
+      trafficAllocation: config.traffic,
+      distribution: config.distribution.map((percentage, index) => ({
+        index,
+        start: config.distribution.slice(0, index).reduce((a, b) => a + b, 0),
+        end: config.distribution.slice(0, index + 1).reduce((a, b) => a + b, 0)
+      })),
+      components: config.components.map(component => {
+        return {
+          baseline: component.baseline,
+          variants: component.variants.map(variant => {
+            if (variant.hidden) {
+              return variant;
+            }
+
+            const matchingVariant = variantReferences.find(variantReference => variantReference.sys.id === variant.id);
+
+            if (!matchingVariant) {
+              return null;
+            }
+
+            return _mapVariant(matchingVariant, {
+              hidden: variant.hidden
+            });
+          }).filter(variant => variant !== null)
+        };
+      })
+    });
+  }
+
+  static mapExperiment(entry) {
+    return ExperienceMapper.mapExperience(entry, {
+      mapVariant: () => ({
+        id: '',
+        hidden: false
+      })
+    });
+  }
+
+  static mapBaselineWithExperiences(entry) {
+    return entry.fields.nt_experiences.filter(isEntry).map(experience => ExperienceMapper.mapExperience(experience));
+  }
+
+}
+
+const isAudienceEntry = entry => {
+  try {
+    AudienceEntry.parse(entry);
+    return true;
+  } catch (error) {
+    return false;
+  }
+};
+
+const isExperienceEntry = entry => {
+  try {
+    ExperienceEntry.parse(entry);
+    return true;
+  } catch (error) {
+    console.error(error);
+    return false;
+  }
+};
+
+export { AudienceEntry, AudienceMapper, Entry, ExperienceEntry, ExperienceMapper, isAudienceEntry, isEntry, isExperienceEntry };

package/index.umd.js

@@ -0,0 +1,278 @@
+(function (global, factory) {
+  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('zod')) :
+  typeof define === 'function' && define.amd ? define(['exports', 'zod'], factory) :
+  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.UtilsContentful = {}, global.zod));
+})(this, (function (exports, zod) { 'use strict';
+
+  var EntryLink = zod.z.object({
+    type: zod.z.literal('Link'),
+    linkType: zod.z.string(),
+    id: zod.z.string()
+  });
+  var Entry = zod.z.object({
+    sys: zod.z.object({
+      type: zod.z.string(),
+      id: zod.z.string(),
+      createdAt: zod.z.string(),
+      updatedAt: zod.z.string(),
+      locale: zod.z.string(),
+      revision: zod.z.number().optional(),
+      space: zod.z.object({
+        sys: EntryLink.extend({
+          linkType: zod.z.literal('Space')
+        })
+      }).optional(),
+      environment: zod.z.object({
+        sys: EntryLink.extend({
+          linkType: zod.z.literal('Environment')
+        })
+      }).optional(),
+      contentType: zod.z.object({
+        sys: EntryLink.extend({
+          linkType: zod.z.literal('ContentType')
+        })
+      })
+    }),
+    fields: zod.z.object({}),
+    metadata: zod.z.object({
+      tags: zod.z.array(zod.z.object({
+        sys: EntryLink.extend({
+          linkType: zod.z.literal('Tag')
+        })
+      }))
+    })
+  });
+
+  var AudienceFields = zod.z.object({
+    /**
+     * The name of the audience (Short Text)
+     */
+    nt_name: zod.z.string(),
+
+    /**
+     * The internal id of the audience (Short Text)
+     */
+    nt_audience_id: zod.z.string()
+  });
+  var AudienceEntry = Entry.extend({
+    fields: AudienceFields
+  });
+
+  var ExperienceFields = zod.z.object({
+    /**
+     * The name of the experience (Short Text)
+     */
+    nt_name: zod.z.string(),
+
+    /**
+     * The type if the experience (nt_experiment | nt_personalization)
+     */
+    nt_type: zod.z.union([zod.z.literal('nt_experiment'), zod.z.literal('nt_personalization')]),
+
+    /**
+     * The config of the experience (JSON)
+     */
+    nt_config: zod.z.object({
+      distribution: zod.z.array(zod.z.number()),
+      traffic: zod.z.number(),
+      components: zod.z.array(zod.z.object({
+        baseline: zod.z.object({
+          id: zod.z.string()
+        }),
+        variants: zod.z.array(zod.z.object({
+          id: zod.z.string(),
+          hidden: zod.z.boolean()
+        }))
+      }))
+    }).optional().nullable(),
+
+    /**
+     * The audience of the experience (Audience)
+     */
+    nt_audience: AudienceEntry.optional().nullable(),
+
+    /**
+     * All used variants of the experience (Contentful references to other Content Types)
+     */
+    nt_variants: zod.z.array(Entry).default([])
+  });
+  var ExperienceEntry = Entry.extend({
+    fields: ExperienceFields
+  });
+
+  var AudienceMapper =
+  /** @class */
+  function () {
+    function AudienceMapper() {}
+
+    AudienceMapper.mapAudience = function (audience) {
+      return {
+        id: audience.sys.id
+      };
+    };
+
+    return AudienceMapper;
+  }();
+
+  /*! *****************************************************************************
+  Copyright (c) Microsoft Corporation.
+
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted.
+
+  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+  REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+  AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+  INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+  LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+  OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+  PERFORMANCE OF THIS SOFTWARE.
+  ***************************************************************************** */
+
+  var __assign = function() {
+      __assign = Object.assign || function __assign(t) {
+          for (var s, i = 1, n = arguments.length; i < n; i++) {
+              s = arguments[i];
+              for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
+          }
+          return t;
+      };
+      return __assign.apply(this, arguments);
+  };
+
+  var isEntry = function (entry) {
+    try {
+      Entry.parse(entry);
+      return true;
+    } catch (error) {
+      return false;
+    }
+  };
+
+  var defaultMapVariant = function (variant, _a) {
+    var hidden = _a.hidden;
+    return __assign(__assign({}, variant), {
+      id: variant.sys.id,
+      hidden: hidden
+    });
+  };
+
+  var ExperienceMapper =
+  /** @class */
+  function () {
+    function ExperienceMapper() {}
+
+    ExperienceMapper.mapExperience = function (entry, options) {
+      var _mapVariant = (options === null || options === void 0 ? void 0 : options.mapVariant) || defaultMapVariant;
+
+      var config = __assign({
+        traffic: 0,
+        distribution: [0.5, 0.5],
+        components: [{
+          baseline: {
+            id: ''
+          },
+          variants: [{
+            id: '',
+            hidden: false
+          }]
+        }]
+      }, entry.fields.nt_config);
+
+      var variantReferences = (entry.fields.nt_variants || []).filter(isEntry);
+      return __assign(__assign({
+        id: entry.sys.id,
+        type: entry.fields.nt_type
+      }, entry.fields.nt_audience ? {
+        audience: AudienceMapper.mapAudience(entry.fields.nt_audience)
+      } : {}), {
+        trafficAllocation: config.traffic,
+        distribution: config.distribution.map(function (percentage, index) {
+          return {
+            index: index,
+            start: config.distribution.slice(0, index).reduce(function (a, b) {
+              return a + b;
+            }, 0),
+            end: config.distribution.slice(0, index + 1).reduce(function (a, b) {
+              return a + b;
+            }, 0)
+          };
+        }),
+        components: config.components.map(function (component) {
+          return {
+            baseline: component.baseline,
+            variants: component.variants.map(function (variant) {
+              if (variant.hidden) {
+                return variant;
+              }
+
+              var matchingVariant = variantReferences.find(function (variantReference) {
+                return variantReference.sys.id === variant.id;
+              });
+
+              if (!matchingVariant) {
+                return null;
+              }
+
+              return _mapVariant(matchingVariant, {
+                hidden: variant.hidden
+              });
+            }).filter(function (variant) {
+              return variant !== null;
+            })
+          };
+        })
+      });
+    };
+
+    ExperienceMapper.mapExperiment = function (entry) {
+      return ExperienceMapper.mapExperience(entry, {
+        mapVariant: function () {
+          return {
+            id: '',
+            hidden: false
+          };
+        }
+      });
+    };
+
+    ExperienceMapper.mapBaselineWithExperiences = function (entry) {
+      return entry.fields.nt_experiences.filter(isEntry).map(function (experience) {
+        return ExperienceMapper.mapExperience(experience);
+      });
+    };
+
+    return ExperienceMapper;
+  }();
+
+  var isAudienceEntry = function (entry) {
+    try {
+      AudienceEntry.parse(entry);
+      return true;
+    } catch (error) {
+      return false;
+    }
+  };
+
+  var isExperienceEntry = function (entry) {
+    try {
+      ExperienceEntry.parse(entry);
+      return true;
+    } catch (error) {
+      console.error(error);
+      return false;
+    }
+  };
+
+  exports.AudienceEntry = AudienceEntry;
+  exports.AudienceMapper = AudienceMapper;
+  exports.Entry = Entry;
+  exports.ExperienceEntry = ExperienceEntry;
+  exports.ExperienceMapper = ExperienceMapper;
+  exports.isAudienceEntry = isAudienceEntry;
+  exports.isEntry = isEntry;
+  exports.isExperienceEntry = isExperienceEntry;
+
+  Object.defineProperty(exports, '__esModule', { value: true });
+
+}));

package/{src/lib → lib}/AudienceMapper.d.ts

@@ -1,6 +1,6 @@
-import { AudienceEntry } from '../types/AudienceEntry';
-export declare class AudienceMapper {
-    static mapAudience(audience: AudienceEntry): {
-        id: string;
-    };
-}
+import { AudienceEntry } from '../types/AudienceEntry';
+export declare class AudienceMapper {
+    static mapAudience(audience: AudienceEntry): {
+        id: string;
+    };
+}

package/lib/ExperienceMapper.d.ts

@@ -0,0 +1,16 @@
+import { Variant, ExperienceConfiguration } from '@ninetailed/experience.js';
+import { ExperienceEntry, Entry } from '../types';
+import { BaselineWithExperiencesEntry } from '../types/BaselineWithExperiencesEntry';
+declare type MapVariantOptions = {
+    hidden: boolean;
+};
+declare type MapVariant<VariantType = Entry> = (variant: VariantType, options: MapVariantOptions) => Variant;
+declare type MapExperienceOptions<VariantType = Entry> = {
+    mapVariant?: MapVariant<VariantType>;
+};
+export declare class ExperienceMapper {
+    static mapExperience(entry: ExperienceEntry, options?: MapExperienceOptions): ExperienceConfiguration;
+    static mapExperiment(entry: ExperienceEntry): ExperienceConfiguration;
+    static mapBaselineWithExperiences(entry: BaselineWithExperiencesEntry): ExperienceConfiguration[];
+}
+export {};

package/lib/index.d.ts

@@ -0,0 +1,5 @@
+export { AudienceMapper } from './AudienceMapper';
+export { ExperienceMapper } from './ExperienceMapper';
+export { isEntry } from './isEntry';
+export { isAudienceEntry } from './isAudienceEntry';
+export { isExperienceEntry } from './isExperienceEntry';

package/lib/isAudienceEntry.d.ts

@@ -0,0 +1,84 @@
+export declare const isAudienceEntry: (entry?: {
+    sys: {
+        revision?: number | undefined;
+        space?: {
+            sys: {
+                type: "Link";
+                id: string;
+                linkType: "Space";
+            };
+        } | undefined;
+        environment?: {
+            sys: {
+                type: "Link";
+                id: string;
+                linkType: "Environment";
+            };
+        } | undefined;
+        type: string;
+        id: string;
+        createdAt: string;
+        updatedAt: string;
+        locale: string;
+        contentType: {
+            sys: {
+                type: "Link";
+                id: string;
+                linkType: "ContentType";
+            };
+        };
+    };
+    fields: {};
+    metadata: {
+        tags: {
+            sys: {
+                type: "Link";
+                id: string;
+                linkType: "Tag";
+            };
+        }[];
+    };
+} | undefined) => entry is {
+    sys: {
+        revision?: number | undefined;
+        space?: {
+            sys: {
+                type: "Link";
+                id: string;
+                linkType: "Space";
+            };
+        } | undefined;
+        environment?: {
+            sys: {
+                type: "Link";
+                id: string;
+                linkType: "Environment";
+            };
+        } | undefined;
+        type: string;
+        id: string;
+        createdAt: string;
+        updatedAt: string;
+        locale: string;
+        contentType: {
+            sys: {
+                type: "Link";
+                id: string;
+                linkType: "ContentType";
+            };
+        };
+    };
+    fields: {
+        nt_name: string;
+        nt_audience_id: string;
+    };
+    metadata: {
+        tags: {
+            sys: {
+                type: "Link";
+                id: string;
+                linkType: "Tag";
+            };
+        }[];
+    };
+};

package/lib/isEntry.d.ts

@@ -0,0 +1,81 @@
+export declare const isEntry: (entry?: {
+    sys: {
+        revision?: number | undefined;
+        space?: {
+            sys: {
+                type: "Link";
+                id: string;
+                linkType: "Space";
+            };
+        } | undefined;
+        environment?: {
+            sys: {
+                type: "Link";
+                id: string;
+                linkType: "Environment";
+            };
+        } | undefined;
+        type: string;
+        id: string;
+        createdAt: string;
+        updatedAt: string;
+        locale: string;
+        contentType: {
+            sys: {
+                type: "Link";
+                id: string;
+                linkType: "ContentType";
+            };
+        };
+    };
+    fields: {};
+    metadata: {
+        tags: {
+            sys: {
+                type: "Link";
+                id: string;
+                linkType: "Tag";
+            };
+        }[];
+    };
+} | undefined) => entry is {
+    sys: {
+        revision?: number | undefined;
+        space?: {
+            sys: {
+                type: "Link";
+                id: string;
+                linkType: "Space";
+            };
+        } | undefined;
+        environment?: {
+            sys: {
+                type: "Link";
+                id: string;
+                linkType: "Environment";
+            };
+        } | undefined;
+        type: string;
+        id: string;
+        createdAt: string;
+        updatedAt: string;
+        locale: string;
+        contentType: {
+            sys: {
+                type: "Link";
+                id: string;
+                linkType: "ContentType";
+            };
+        };
+    };
+    fields: {};
+    metadata: {
+        tags: {
+            sys: {
+                type: "Link";
+                id: string;
+                linkType: "Tag";
+            };
+        }[];
+    };
+};