@player-tools/fluent 0.12.1--canary.241.6077

package/src/core/mocks/generated/text.builder.ts

@@ -0,0 +1,47 @@
+import type { TextAsset } from "../types/text.js";
+import { type FluentBuilder, type BaseBuildContext, type FluentPartial, FluentBuilderBase, createInspectMethod, type TaggedTemplateValue } from "../../../gen/common.js";
+
+export interface TextAssetBuilderMethods {
+  /** A unique identifier for this asset */
+  withId(value: string | TaggedTemplateValue<string>): TextAssetBuilder;
+  /** Sets the value property */
+  withValue(value: string | TaggedTemplateValue<string>): TextAssetBuilder;
+}
+
+/**
+ * A builder for TextAsset
+ */
+export class TextAssetBuilder extends FluentBuilderBase<TextAsset> implements TextAssetBuilderMethods, FluentBuilder<TextAsset, BaseBuildContext> {
+  private static readonly defaults: Record<string, unknown> = {"type":"text","id":"","value":""};
+
+  /** A unique identifier for this asset */
+  withId(value: string | TaggedTemplateValue<string>): TextAssetBuilder {
+    return this.set("id", value);
+  }
+
+  /** Sets the value property */
+  withValue(value: string | TaggedTemplateValue<string>): TextAssetBuilder {
+    return this.set("value", value);
+  }
+
+  /**
+   * Builds the final TextAsset object
+   * @param context - Optional build context for nested builders
+   */
+  build(context?: BaseBuildContext): TextAsset {
+    return this.buildWithDefaults(TextAssetBuilder.defaults, context);
+  }
+
+  [Symbol.for("nodejs.util.inspect.custom")](): string {
+    return createInspectMethod("TextAssetBuilder", this.values);
+  }
+}
+
+/**
+ * Creates a new TextAsset builder
+ * @param initial Optional initial values
+ * @returns A fluent builder for TextAsset
+ */
+export function text(initial?: FluentPartial<TextAsset>): TextAssetBuilder {
+  return new TextAssetBuilder(initial);
+}

package/src/core/mocks/index.ts

@@ -0,0 +1 @@
+export * from "./generated";

package/src/core/mocks/types/action.ts

@@ -0,0 +1,92 @@
+import type {
+  Asset,
+  AssetWrapper,
+  Binding,
+  Expression,
+} from "@player-ui/types";
+
+export interface SimpleModifier<Type extends string> {
+  /** THe mofifier type */
+  type: Type;
+}
+
+export const ActionRoles = [
+  "primary",
+  "secondary",
+  "tertiary",
+  "upsell",
+  "back",
+  "link",
+  "inline-link",
+  "tertiary-button",
+] as const;
+
+export type ActionRole = (typeof ActionRoles)[number];
+
+/**
+ * User actions can be represented in several places.
+ * Each view typically has one or more actions that allow the user to navigate away from that view.
+ * In addition, several asset types can have actions that apply to that asset only.
+ */
+export interface ActionAsset<AnyAsset extends Asset = Asset>
+  extends Asset<"action"> {
+  /** The transition value of the action in the state machine */
+  value?: string;
+
+  /** A text-like asset for the action's label */
+  label?: AssetWrapper<AnyAsset>;
+
+  /** An optional expression to execute before transitioning */
+  exp?: Expression;
+
+  /** An optional string that describes the action for screen-readers */
+  accessibility?: string;
+
+  /** An optional confirmation dialog to show before executing the action */
+  confirmation?: {
+    /** message asking for confirmation */
+    message: string;
+    /** label for the confirm button */
+    affirmativeLabel: string;
+    /** label for the deny button */
+    negativeLabel?: string;
+  };
+
+  /** Additional optional data to assist with the action interactions on the page */
+  metaData?: ActionMetaData;
+
+  /** Triggers the listed bindings to be validated */
+  validate?: Array<Binding> | Binding;
+}
+
+export interface ActionMetaData {
+  // Can't pull from @cg-player/types b/c of circular dependencies
+  /** beacon to send when the action runs */
+  beacon?: string | Record<string, unknown>;
+
+  /**
+   * A semantic hint to render the action in different user contexts
+   */
+  role?: ActionRole;
+
+  /** Force transition to the next view without checking for validation TODO need to update this to support an expression */
+  skipValidation?: boolean;
+
+  /** Size of the button */
+  size?: "small" | "medium" | "large";
+
+  /** true to indicate the button should be disabled */
+  disabled?: boolean;
+
+  /** true to indicate that the button label should be hidden */
+  hideLabel?: boolean;
+
+  /** true to indicate that the button icon should be hidden */
+  hideIcon?: boolean;
+
+  /** true to indicate that the action should display as a button instead of a link */
+  showAsButton?: boolean;
+
+  /** true to indicate to take container width, responsive: Full Width on mobile */
+  fullWidth?: boolean | "responsive";
+}

package/src/core/mocks/types/choice.ts

@@ -0,0 +1,129 @@
+import type { Asset, AssetWrapper, Binding } from "@player-ui/types";
+
+export const ALL_CATEGORIES = ["recommended"] as const;
+
+export type ChoiceItemCategory = (typeof ALL_CATEGORIES)[number];
+
+/** Any modifier that can appear on a choice */
+export type ChoiceModifier = {
+  /** The default type */
+  type: "tag";
+
+  /** A compact modifier renders a radio button as a dropdown  */
+  value: "compact";
+};
+
+/** Optional tag to set choice as readonly */
+export type ChoiceInputModifier = {
+  /** The default type */
+  type: "input";
+
+  /** modifier to set the choices to readonly */
+  value: "readonly";
+};
+
+export type ChoiceItemMetadata = {
+  /** optional category for the choice item to determine its purpose:
+   * recommended: this choice item is recommended for the user over or in addition to other items
+   */
+  category?: ChoiceItemCategory;
+};
+
+export interface ChoiceItem<AnyAsset extends Asset = Asset> {
+  /** The id associated with the choice item */
+  id: string;
+
+  /** The id used for replay tests. */
+  automationId?: string;
+
+  /** The label describing the choice. */
+  label?: AssetWrapper<AnyAsset>;
+
+  /** The icon describing the choice. */
+  icon?: AssetWrapper<AnyAsset>;
+
+  /** The help for the choice. */
+  help?: AssetWrapper<AnyAsset>;
+
+  /** Support the legacy choiceHelp prop. No storybook docs for this; deprecated in favour of the "help" field. */
+  choiceHelp?: AssetWrapper<AnyAsset>;
+
+  /** The description of the choice. */
+  description?: AssetWrapper<AnyAsset>;
+
+  /** The footer of the choice. */
+  footer?: AssetWrapper<AnyAsset>;
+
+  /**
+   * The value to set when this choice is selected
+   */
+  value?: string | number | boolean | null;
+
+  /** The details shown when a user selects the choice item */
+  choiceDetail?: AssetWrapper<AnyAsset>;
+  /**
+   * Any modifiers for the current item. No storybook docs for this as "readonly" (the only modifier) shouldn't be used anymore.
+   */
+  modifiers?: Array<ChoiceInputModifier>;
+
+  /** MetaData for the choiceItem */
+  metaData?: ChoiceItemMetadata;
+}
+
+export interface ChoiceMetaData {
+  /** Display the asset a little differently based on the role, monthselector only applies to multiselect asset */
+  role?: "tiles" | "monthselector"; // problem with Omit again, can't omit metaData on choiceProps and redefine it
+
+  /** used to set tiles to jumbo manually */
+  tileSize?: "jumbo" | undefined;
+
+  /** should The placeholder be disabled or not */
+  placeholderSelectable?: boolean;
+}
+
+/**
+ * Choice assets are more specific type of data collection element
+ *  where user is presented with a number of predefined choices and
+ * asked to select a single answer.
+ */
+export interface ChoiceAsset<AnyAsset extends Asset = Asset>
+  extends Asset<"choice"> {
+  /** The binding used to keep track of the selected Choice */
+  binding: Binding;
+
+  /** The choiceItems used as options */
+  choices?: Array<ChoiceItem<AnyAsset>>;
+
+  /** The label describing the choice field. */
+  label?: AssetWrapper<AnyAsset>;
+
+  /** choice help providing additional info that could be helpful  */
+  help?: AssetWrapper<AnyAsset>;
+
+  /** choice note */
+  note?: AssetWrapper;
+
+  /** placeholder string to show by default for the choice */
+  placeholder?: string;
+
+  /** any accessibility text to be added as an aria label.*/
+  accessibility?: string;
+
+  /** The info that appears underneath the choice  */
+  additionalInfo?: AssetWrapper<AnyAsset>;
+
+  /** The resulting Text that appears underneath the choice */
+  resultText?: AssetWrapper<AnyAsset>;
+
+  /** */
+  modifiers?: Array<ChoiceModifier | ChoiceInputModifier>;
+
+  /** Additional metaData for the Choice */
+  metaData?: ChoiceMetaData;
+
+  /** The main action associated with choices */
+  action?: AssetWrapper<AnyAsset>;
+
+  /** The main image associated with choices */
+  image?: AssetWrapper<AnyAsset>;
+}

package/src/core/mocks/types/collection.ts

@@ -0,0 +1,140 @@
+import type { Asset, AssetWrapper } from "@player-ui/types";
+import { ActionAsset } from "./action";
+
+/** A Modifier to apply 'highlight' styling to the collection */
+export interface CalloutModifier {
+  /** the type of modifier */
+  type: "callout";
+  /** specification on why the callout needs to be highlighted--this determines the coloring  */
+  value: "support" | "legal";
+}
+export interface TagModifier {
+  /** the type of modifier */
+  type: "tag";
+  /** the value for the tag */
+  value: "block";
+}
+export interface CollectionMetaData {
+  /** the role of the collection */
+  role?:
+    | "section"
+    | "ocr-surface"
+    | "ocr-instructions-lighting"
+    | "ocr-instructions-positioning"
+    | "swd-head-start-text"
+    | "premium"
+    | "address";
+}
+/**
+ * A collection is a group of assets
+ *
+ * @asset
+ */
+export interface Collection<AnyAsset extends Asset = Asset>
+  extends Asset<"collection"> {
+  /** The collection items to show */
+  values?: Array<AssetWrapper<AnyAsset>>;
+
+  /** The additional information to  show */
+  additionalInfo?: AssetWrapper<AnyAsset>;
+
+  /** The result text to show */
+  resultText?: AssetWrapper<AnyAsset> | Array<AssetWrapper<AnyAsset>>;
+
+  /** The label defining the collection  */
+  label?: AssetWrapper<AnyAsset>;
+
+  /** Actions attached to the collection */
+  actions?: Array<AssetWrapper<ActionAsset>>;
+
+  /** Extra data associated with the collection */
+  metaData?: CollectionMetaData;
+
+  /** Ways to modify how the component looks */
+  modifiers?: Array<CalloutModifier | TagModifier>;
+}
+
+export interface FieldCollectionMetaData {
+  /** the role of the field collection */
+  role?: "section" | "address" | "name" | "phone";
+}
+/**
+ * A field collection is a group of field assets
+ *
+ * @asset
+ */
+export interface FieldCollection<AnyAsset extends Asset = Asset>
+  extends Asset<"fieldCollection"> {
+  /** The collection items to show */
+  values?: Array<AssetWrapper<AnyAsset>>;
+
+  /** The additional information to  show */
+  additionalInfo?: AssetWrapper<AnyAsset>;
+
+  /** The result text to show */
+  resultText?: AssetWrapper<AnyAsset>;
+
+  /** The label defining the collection  */
+  label?: AssetWrapper<AnyAsset>;
+
+  /** Extra data associated with the collection */
+  metaData?: FieldCollectionMetaData;
+
+  /** Actions attached to the collection */
+  actions?: Array<AssetWrapper<ActionAsset>>;
+}
+/**
+ * The OverviewCollection asset
+ *
+ * @asset
+ */
+export interface OverviewCollection<AnyAsset extends Asset = Asset>
+  extends Asset<"overviewCollection"> {
+  /** The collection items to show */
+  values?: Array<AssetWrapper<AnyAsset>>;
+
+  /** The label defining the collection  */
+  label?: AssetWrapper<AnyAsset>;
+
+  /** Actions attached to the collection */
+  actions?: Array<AssetWrapper<ActionAsset>>;
+}
+
+/**
+ * SplashCollection asset is very similar to the basic Collection, which is a group of assets.
+ * It can also contain an image. It is intended to display read-only data.
+ */
+export interface SplashCollection<AnyAsset extends Asset = Asset>
+  extends Asset<"splashCollection"> {
+  /** Extra data associated with the Asset */
+  metaData?: {
+    /** Changes the style slightly */
+    role?: "promotional";
+  };
+
+  /** Asset container for an image */
+  splash?: AssetWrapper<AnyAsset>;
+
+  /** Label, typically a single text asset */
+  label?: AssetWrapper<AnyAsset>;
+
+  /** Array of assets, typically text assets */
+  values?: Array<AssetWrapper<AnyAsset>>;
+
+  /** @deprecated additionalInfo in splash collection is no longer supported */
+  additionalInfo?: AssetWrapper<AnyAsset>;
+
+  /** @deprecated resultText in splash collection is no longer supported */
+  resultText?: AssetWrapper<AnyAsset>;
+
+  /** @deprecated actions in splash collection is no longer supported */
+  actions?: Array<AssetWrapper<ActionAsset>>;
+}
+
+export type CollectionType =
+  | Collection
+  | FieldCollection
+  | OverviewCollection
+  | SplashCollection;
+
+export type CollectionValue = AssetWrapper<Asset<string>>;

package/src/core/mocks/types/info.ts

@@ -0,0 +1,7 @@
+import type { Asset, AssetWrapper } from "@player-ui/types";
+
+export interface InfoAsset extends Asset<"info"> {
+  primaryInfo: Array<AssetWrapper<Asset>>;
+  title?: AssetWrapper<Asset>;
+  subtitle?: AssetWrapper<Asset>;
+}

package/src/core/mocks/types/input.ts

@@ -0,0 +1,7 @@
+import type { Asset, AssetWrapper } from "@player-ui/types";
+
+export interface InputAsset extends Asset<"input"> {
+  binding: string;
+  label: AssetWrapper<Asset>;
+  placeholder?: string;
+}

package/src/core/mocks/types/text.ts

@@ -0,0 +1,5 @@
+import type { Asset } from "@player-ui/types";
+
+export interface TextAsset extends Asset<"text"> {
+  value: string;
+}

package/src/core/schema/__tests__/index.test.ts

@@ -0,0 +1,127 @@
+import { test, expect } from "vitest";
+import { SchemaGenerator } from "..";
+
+const BasicDataType = {
+  type: "StringType",
+};
+
+test("generates proper schema", () => {
+  const schemaGenerator = new SchemaGenerator();
+
+  expect(
+    schemaGenerator.toSchema({
+      foo: {
+        bar: {
+          baz: BasicDataType,
+        },
+      },
+      other: [
+        {
+          item1: BasicDataType,
+        },
+      ],
+    }),
+  ).toStrictEqual({
+    ROOT: {
+      foo: {
+        type: "fooType",
+      },
+      other: {
+        type: "otherType",
+        isArray: true,
+      },
+    },
+    fooType: {
+      bar: {
+        type: "barType",
+      },
+    },
+    barType: {
+      baz: {
+        type: "StringType",
+      },
+    },
+    otherType: {
+      item1: {
+        type: "StringType",
+      },
+    },
+  });
+});
+
+test("Edge Case - two artificial array nodes", () => {
+  const schemaGenerator = new SchemaGenerator();
+
+  expect(
+    schemaGenerator.toSchema({
+      foo: {
+        bar: [
+          {
+            baa: BasicDataType,
+          },
+        ],
+      },
+      other: {
+        bar: [
+          {
+            bab: BasicDataType,
+          },
+        ],
+      },
+      another: {
+        bar: [
+          {
+            bac: BasicDataType,
+          },
+        ],
+      },
+    }),
+  ).toMatchInlineSnapshot(`
+    {
+      "ROOT": {
+        "another": {
+          "type": "anotherType",
+        },
+        "foo": {
+          "type": "fooType",
+        },
+        "other": {
+          "type": "otherType",
+        },
+      },
+      "anotherType": {
+        "bar": {
+          "isArray": true,
+          "type": "barType",
+        },
+      },
+      "barType": {
+        "bac": {
+          "type": "StringType",
+        },
+      },
+      "barType2": {
+        "bab": {
+          "type": "StringType",
+        },
+      },
+      "barType3": {
+        "baa": {
+          "type": "StringType",
+        },
+      },
+      "fooType": {
+        "bar": {
+          "isArray": true,
+          "type": "barType3",
+        },
+      },
+      "otherType": {
+        "bar": {
+          "isArray": true,
+          "type": "barType2",
+        },
+      },
+    }
+  `);
+});