@pie-element/likert 4.1.0-next.28 → 4.1.1-next.0

package/dist/author/main.js

@@ -0,0 +1,298 @@
+import e from "../node_modules/.bun/lodash-es@4.18.1/node_modules/lodash-es/merge.js";
+import { LIKERT_ORIENTATION as t, LIKERT_SCALE as n, LIKERT_TYPE as r } from "./likertEntities.js";
+import i from "./choiceGenerator.js";
+import a from "react";
+import o from "prop-types";
+import { color as s } from "@pie-lib/render-ui";
+import { jsx as c, jsxs as l } from "react/jsx-runtime";
+import u from "@mui/material/FormControlLabel";
+import { styled as d } from "@mui/material/styles";
+import f from "@mui/material/Radio";
+import p from "@pie-lib/editable-html-tip-tap";
+import m from "@mui/material/RadioGroup";
+import { InputContainer as h, NumberTextField as g, layout as _, settings as v } from "@pie-lib/config-ui";
+//#region src/author/main.tsx
+var { Panel: y, toggle: b, radio: x } = v, S = d(h)(({ theme: e }) => ({
+	width: "100%",
+	paddingTop: e.spacing(2),
+	marginBottom: e.spacing(2)
+})), C = d("div")({
+	display: "flex",
+	flexDirection: "column"
+}), w = d("p")(({ theme: e }) => ({
+	color: e.palette.grey[400],
+	fontSize: e.typography.fontSize - 2
+})), T = d("div")(({ theme: e }) => ({
+	display: "flex",
+	width: "100%",
+	alignItems: "flex-start",
+	marginBottom: e.spacing(2)
+})), E = d("div")(({ theme: e }) => ({
+	display: "flex",
+	width: "100%",
+	justifyContent: "space-around",
+	marginBottom: e.spacing(2.5)
+})), D = d(h)({
+	width: "calc(100% - 200px)",
+	marginRight: 0
+}), O = d("p")(({ theme: e }) => ({
+	color: e.palette.error.main,
+	fontSize: e.typography.fontSize - 2
+})), k = d(g)({ width: "100%" }), A = d("div")({
+	display: "flex",
+	flexDirection: "row"
+}), j = d("div")(({ theme: e }) => ({
+	paddingLeft: e.spacing(2.5),
+	width: "150px"
+})), M = d(p)(({ theme: e }) => ({ paddingTop: e.spacing(2) })), N = d("span")(({ theme: e }) => ({
+	width: "30px",
+	paddingTop: e.spacing(4)
+})), P = d("div")(({ theme: e }) => ({
+	fontSize: e.typography.fontSize - 2,
+	color: e.palette.error.main,
+	paddingTop: e.spacing(1)
+})), F = d(f)({ color: `${s.tertiary()} !important` }), I = (e) => {
+	let { model: n, onChangeModel: r } = e;
+	return /* @__PURE__ */ l(C, { children: [/* @__PURE__ */ c(w, { children: "Likert Orientation" }), /* @__PURE__ */ l(m, {
+		"aria-label": "likertOrientation",
+		name: "likertOrientation",
+		value: n.likertOrientation,
+		onChange: (e) => {
+			let t = e.target.value;
+			r({
+				...n,
+				likertOrientation: t
+			});
+		},
+		children: [/* @__PURE__ */ c(u, {
+			value: t.horizontal,
+			control: /* @__PURE__ */ c(F, {}),
+			label: "Horizontal"
+		}), /* @__PURE__ */ c(u, {
+			value: t.vertical,
+			control: /* @__PURE__ */ c(F, {}),
+			label: "Vertical"
+		})]
+	})] });
+}, L = (e) => {
+	let { model: t, onChangeModel: r } = e;
+	return /* @__PURE__ */ l(C, { children: [/* @__PURE__ */ c(w, { children: "Likert Scale" }), /* @__PURE__ */ l(m, {
+		"aria-label": "likertScale",
+		name: "likertScale",
+		value: t.likertScale,
+		onChange: (e) => {
+			let n = e.target.value;
+			r({
+				...t,
+				likertScale: n,
+				choices: i(n, t.likertType)
+			});
+		},
+		children: [
+			/* @__PURE__ */ c(u, {
+				value: n.likert3,
+				control: /* @__PURE__ */ c(F, {}),
+				label: "Likert 3"
+			}),
+			/* @__PURE__ */ c(u, {
+				value: n.likert5,
+				control: /* @__PURE__ */ c(F, {}),
+				label: "Likert 5"
+			}),
+			/* @__PURE__ */ c(u, {
+				value: n.likert7,
+				control: /* @__PURE__ */ c(F, {}),
+				label: "Likert 7"
+			})
+		]
+	})] });
+}, R = (e) => {
+	let { model: t, onChangeModel: n } = e, a = (e) => {
+		let r = e.target.value;
+		n({
+			...t,
+			likertType: r,
+			choices: i(t.likertScale, r)
+		});
+	};
+	return /* @__PURE__ */ l(C, { children: [/* @__PURE__ */ c(w, { children: "Label Type" }), /* @__PURE__ */ l(A, { children: [/* @__PURE__ */ l(m, {
+		"aria-label": "likertLabelType",
+		name: "likertLabelType",
+		value: t.likertType,
+		onChange: a,
+		children: [
+			/* @__PURE__ */ c(u, {
+				value: r.agreement,
+				control: /* @__PURE__ */ c(F, {}),
+				label: "Agreement"
+			}),
+			/* @__PURE__ */ c(u, {
+				value: r.frequency,
+				control: /* @__PURE__ */ c(F, {}),
+				label: "Frequency"
+			}),
+			/* @__PURE__ */ c(u, {
+				value: r.yesNo,
+				control: /* @__PURE__ */ c(F, {}),
+				label: "Yes/No"
+			})
+		]
+	}), /* @__PURE__ */ l(m, {
+		"aria-label": "likertLabelType",
+		name: "likertLabelType",
+		value: t.likertType,
+		onChange: a,
+		children: [
+			/* @__PURE__ */ c(u, {
+				value: r.importance,
+				control: /* @__PURE__ */ c(F, {}),
+				label: "Importance"
+			}),
+			/* @__PURE__ */ c(u, {
+				value: r.likelihood,
+				control: /* @__PURE__ */ c(F, {}),
+				label: "Likelihood"
+			}),
+			/* @__PURE__ */ c(u, {
+				value: r.like,
+				control: /* @__PURE__ */ c(F, {}),
+				label: "Like"
+			})
+		]
+	})] })] });
+}, z = (e) => e.choices.reduce((e, t) => {
+	let n = { ...e }, r = parseInt(t.value);
+	return n[r] || (n[r] = 0), {
+		...n,
+		[r]: n[r] + 1
+	};
+}, {}), B = (e) => {
+	let { configuration: t, imageSupport: n, model: r, onChangeModel: i, onChoiceChanged: a, onConfigurationChanged: o, onPromptChanged: s, onTeacherInstructionsChanged: u, uploadSoundSupport: d } = e, { contentDimensions: f = {}, prompt: m = {}, scoringType: h = {}, settingsPanelDisabled: g, spellCheck: v = {}, teacherInstructions: C = {}, baseInputConfiguration: w = {}, likertChoice: A = {} } = t || {}, { errors: F = {}, extraCSSRules: B, spellCheckEnabled: V, teacherInstructionsEnabled: H } = r || {}, { prompt: U, teacherInstructions: W } = F, G = z(r), K = {
+		teacherInstructionsEnabled: C.settings && b(C.label),
+		spellCheckEnabled: v.settings && b(v.label),
+		scoringType: h.settings && x(h.label, ["auto", "rubric"])
+	}, q = (e = {}) => Object.assign({ ...w }, e || {});
+	return /* @__PURE__ */ l(_.ConfigLayout, {
+		extraCSSRules: B,
+		dimensions: f,
+		hideSettings: g,
+		settings: /* @__PURE__ */ c(y, {
+			model: r,
+			onChangeModel: i,
+			configuration: t,
+			onChangeConfiguration: o,
+			groups: { Properties: K }
+		}),
+		children: [
+			H && /* @__PURE__ */ l(S, {
+				label: C.label,
+				children: [/* @__PURE__ */ c(p, {
+					markup: r.teacherInstructions || "",
+					onChange: u,
+					imageSupport: n,
+					nonEmpty: !1,
+					error: W,
+					spellCheck: V,
+					uploadSoundSupport: d,
+					pluginProps: q(C?.inputConfiguration)
+				}), W && /* @__PURE__ */ c(P, { children: W })]
+			}),
+			/* @__PURE__ */ l(S, {
+				label: m.label,
+				children: [/* @__PURE__ */ c(p, {
+					markup: r.prompt,
+					onChange: s,
+					imageSupport: n,
+					nonEmpty: !1,
+					error: U,
+					spellCheck: V,
+					disableUnderline: !0,
+					uploadSoundSupport: d,
+					pluginProps: q(m?.inputConfiguration)
+				}), U && /* @__PURE__ */ c(P, { children: U })]
+			}),
+			/* @__PURE__ */ l(E, { children: [
+				/* @__PURE__ */ c(L, {
+					model: r,
+					onChangeModel: i
+				}),
+				/* @__PURE__ */ c(R, {
+					model: r,
+					onChangeModel: i
+				}),
+				/* @__PURE__ */ c(I, {
+					model: r,
+					onChangeModel: i
+				})
+			] }),
+			r.choices.map((e, t) => /* @__PURE__ */ l(T, { children: [
+				/* @__PURE__ */ l(N, { children: [t + 1, "."] }),
+				/* @__PURE__ */ c(D, {
+					label: "Likert Label",
+					children: /* @__PURE__ */ c(M, {
+						markup: e.label || "",
+						onChange: (n) => a(t, {
+							...e,
+							label: n
+						}),
+						imageSupport: n,
+						spellCheck: V,
+						uploadSoundSupport: d,
+						pluginProps: q(A?.inputConfiguration)
+					})
+				}, `likert-label-${t}`),
+				/* @__PURE__ */ l(j, { children: [/* @__PURE__ */ c(k, {
+					label: "Likert Value",
+					value: e.value,
+					max: 100,
+					min: -100,
+					onChange: (n, r) => {
+						a(t, {
+							...e,
+							value: r
+						});
+					},
+					imageSupport: n
+				}), G[e.value] && G[e.value] > 1 && /* @__PURE__ */ c(O, { children: "Value should be unique" })] })
+			] }, `choice-${t}`))
+		]
+	});
+}, V = class extends a.Component {
+	static propTypes = {
+		model: o.object.isRequired,
+		disableSidePanel: o.bool,
+		onModelChanged: o.func.isRequired,
+		onConfigurationChanged: o.func.isRequired,
+		imageSupport: o.shape({
+			add: o.func.isRequired,
+			delete: o.func.isRequired
+		})
+	};
+	onChoiceChanged = (t, n) => {
+		let { model: r, onModelChanged: i } = this.props;
+		r.choices = r.choices.map((t) => e({}, t)), r.choices.splice(t, 1, n), i(r);
+	};
+	onPromptChanged = (e) => {
+		this.props.onModelChanged({
+			...this.props.model,
+			prompt: e
+		});
+	};
+	onTeacherInstructionsChanged = (e) => {
+		this.props.onModelChanged({
+			...this.props.model,
+			teacherInstructions: e
+		});
+	};
+	render() {
+		return /* @__PURE__ */ c(B, {
+			...this.props,
+			onChangeModel: this.props.onModelChanged,
+			onChoiceChanged: this.onChoiceChanged,
+			onPromptChanged: this.onPromptChanged,
+			onTeacherInstructionsChanged: this.onTeacherInstructionsChanged
+		});
+	}
+};
+//#endregion
+export { V as default };

package/dist/controller/defaults.d.ts

@@ -0,0 +1,19 @@
+/**
+ * @synced-from pie-elements/packages/likert/controller/src/defaults.js
+ * @auto-generated
+ *
+ * This file is automatically synced from pie-elements and converted to TypeScript.
+ * Manual edits will be overwritten on next sync.
+ * To make changes, edit the upstream JavaScript file and run sync again.
+ */
+declare const _default: {
+    choices: never[];
+    likertOrientation: string;
+    likertScale: string;
+    likertType: string;
+    prompt: string;
+    promptEnabled: boolean;
+    teacherInstructions: string;
+    teacherInstructionsEnabled: boolean;
+};
+export default _default;

package/dist/controller/defaults.js

@@ -0,0 +1,13 @@
+//#region src/controller/defaults.ts
+var e = {
+	choices: [],
+	likertOrientation: "horizontal",
+	likertScale: "likert3",
+	likertType: "agreement",
+	prompt: "",
+	promptEnabled: !0,
+	teacherInstructions: "",
+	teacherInstructionsEnabled: !0
+};
+//#endregion
+export { e as default };

package/dist/controller/index.d.ts

@@ -0,0 +1,19 @@
+/**
+ * @synced-from pie-elements/packages/likert/controller/src/index.js
+ * @auto-generated
+ *
+ * This file is automatically synced from pie-elements and converted to TypeScript.
+ * Manual edits will be overwritten on next sync.
+ * To make changes, edit the upstream JavaScript file and run sync again.
+ */
+export declare function createDefaultModel(model?: {}): Promise<unknown>;
+export declare const normalize: (question: any) => any;
+/**
+ *
+ * @param {*} question
+ * @param {*} session
+ * @param {*} env
+ */
+export declare function model(question: any, session: any, env: any): Promise<any>;
+export declare function outcome(): Promise<unknown>;
+export declare const validate: (model?: {}, config?: {}) => {};

package/dist/controller/index.js

@@ -0,0 +1,41 @@
+import e from "./defaults.js";
+//#region src/controller/index.ts
+var t = (e) => ({
+	label: e.label,
+	value: e.value
+});
+function n(t = {}) {
+	return new Promise((n) => n({
+		...e,
+		...t
+	}));
+}
+var r = (t) => ({
+	...e,
+	...t
+});
+async function i(e, n, i) {
+	let a = r(e), o = a.choices.map(t), s = {
+		...a,
+		choices: o,
+		disabled: i.mode !== "gather",
+		mode: i.mode
+	}, { role: c, mode: l } = i || {};
+	return c === "instructor" && (l === "view" || l === "evaluate") ? s.teacherInstructions = a.teacherInstructionsEnabled ? a.teacherInstructions : null : s.teacherInstructions = null, s;
+}
+function a() {
+	return new Promise((e) => {
+		e({
+			score: 0,
+			empty: !1
+		});
+	});
+}
+var o = (e) => (e || "").replace(/(<(?!img|iframe|source)([^>]+)>)/gi, ""), s = (e = {}, t = {}) => {
+	let n = {};
+	return ["teacherInstructions", "prompt"].forEach((r) => {
+		t[r]?.required && !o(e[r]) && (n[r] = "This field is required.");
+	}), n;
+};
+//#endregion
+export { n as createDefaultModel, i as model, r as normalize, a as outcome, s as validate };

package/dist/delivery/choice-input.d.ts

@@ -0,0 +1,27 @@
+/**
+ * @synced-from pie-elements/packages/likert/src/choice-input.jsx
+ * @auto-generated
+ *
+ * This file is automatically synced from pie-elements and converted to TypeScript.
+ * Manual edits will be overwritten on next sync.
+ * To make changes, edit the upstream JavaScript file and run sync again.
+ */
+import React from 'react';
+import PropTypes from 'prop-types';
+export declare const RadioStyled: any;
+export declare class ChoiceInput extends React.Component {
+    static propTypes: {
+        checked: PropTypes.Validator<boolean>;
+        disabled: PropTypes.Validator<boolean>;
+        label: PropTypes.Validator<string>;
+        likertOrientation: PropTypes.Validator<string>;
+        onChange: PropTypes.Validator<(...args: any[]) => any>;
+        value: PropTypes.Validator<number>;
+    };
+    static defaultProps: {
+        checked: boolean;
+    };
+    onToggleChoice: any;
+    render(): React.JSX.Element;
+}
+export default ChoiceInput;

package/dist/delivery/choice-input.js

@@ -0,0 +1,59 @@
+import { LIKERT_ORIENTATION as e } from "./likertEntities.js";
+import t from "react";
+import n from "prop-types";
+import { color as r } from "@pie-lib/render-ui";
+import { jsx as i, jsxs as a } from "react/jsx-runtime";
+import o from "@mui/material/FormControlLabel";
+import { styled as s } from "@mui/material/styles";
+import c from "@mui/material/Radio";
+//#region src/delivery/choice-input.tsx
+var l = s(c)({
+	color: `var(--choice-input-color, ${r.text()})`,
+	"&.Mui-checked": { color: `var(--choice-input-selected-color, ${r.primary()})` },
+	"&.Mui-disabled": { color: `var(--choice-input-disabled-color, ${r.defaults.DISABLED})` }
+}), u = s("p")({
+	color: r.text(),
+	textAlign: "center",
+	cursor: "pointer"
+}), d = s("div")({
+	display: "flex",
+	alignItems: "center",
+	flex: 1,
+	padding: "0 5px",
+	"& label": {}
+}), f = s(o)({ margin: 0 }), p = class extends t.Component {
+	static propTypes = {
+		checked: n.bool.isRequired,
+		disabled: n.bool.isRequired,
+		label: n.string.isRequired,
+		likertOrientation: n.string.isRequired,
+		onChange: n.func.isRequired,
+		value: n.number.isRequired
+	};
+	static defaultProps = { checked: !1 };
+	onToggleChoice = () => {
+		this.props.onChange({
+			value: this.props.value,
+			selected: !this.props.checked
+		});
+	};
+	render() {
+		let { disabled: t, label: n, checked: r, likertOrientation: o } = this.props;
+		return /* @__PURE__ */ a(d, {
+			style: { flexDirection: o === e.vertical ? "row" : "column" },
+			children: [/* @__PURE__ */ i(f, {
+				disabled: t,
+				control: /* @__PURE__ */ i(l, {
+					checked: r,
+					onChange: this.onToggleChoice,
+					disabled: t
+				})
+			}), /* @__PURE__ */ i(u, {
+				onClick: this.onToggleChoice,
+				dangerouslySetInnerHTML: { __html: n }
+			})]
+		});
+	}
+};
+//#endregion
+export { p as default };

package/dist/delivery/index.d.ts

@@ -0,0 +1,19 @@
+/**
+ * @synced-from pie-elements/packages/likert/src/index.js
+ * @auto-generated
+ *
+ * This file is automatically synced from pie-elements and converted to TypeScript.
+ * Manual edits will be overwritten on next sync.
+ * To make changes, edit the upstream JavaScript file and run sync again.
+ */
+export declare const isComplete: (session: any) => boolean;
+export default class Likert extends HTMLElement {
+    constructor();
+    set model(m: any);
+    set session(s: any);
+    get session(): any;
+    sessionChanged(s: any): void;
+    connectedCallback(): void;
+    _render(): void;
+    disconnectedCallback(): void;
+}

package/dist/delivery/index.js

@@ -0,0 +1,44 @@
+import e from "./main.js";
+import t from "react";
+import { createRoot as n } from "react-dom/client";
+import { SessionChangedEvent as r } from "@pie-element/shared-player-events";
+import { renderMath as i } from "@pie-element/shared-math-rendering-mathjax";
+//#region src/delivery/index.ts
+var a = (e) => !!(e && e.value && e.value.length), o = class extends HTMLElement {
+	constructor() {
+		super(), this._root = null;
+	}
+	set model(e) {
+		this._model = e, this._render();
+	}
+	set session(e) {
+		this._session = e, this._render();
+	}
+	get session() {
+		return this._session;
+	}
+	sessionChanged(e) {
+		this._session.value = e.value;
+		let t = a(this._session, this._model);
+		this.dispatchEvent(new r(this.tagName.toLowerCase(), t)), this._render();
+	}
+	connectedCallback() {
+		this._render();
+	}
+	_render() {
+		if (!this._model || !this._session) return;
+		let r = t.createElement(e, {
+			model: this._model,
+			session: this._session,
+			onSessionChange: this.sessionChanged.bind(this)
+		});
+		this._root ||= n(this), this._root.render(r), queueMicrotask(() => {
+			i(this);
+		});
+	}
+	disconnectedCallback() {
+		this._root && this._root.unmount();
+	}
+};
+//#endregion
+export { o as default, a as isComplete };

package/dist/delivery/likert.d.ts

@@ -0,0 +1,26 @@
+/**
+ * @synced-from pie-elements/packages/likert/src/likert.jsx
+ * @auto-generated
+ *
+ * This file is automatically synced from pie-elements and converted to TypeScript.
+ * Manual edits will be overwritten on next sync.
+ * To make changes, edit the upstream JavaScript file and run sync again.
+ */
+import React from 'react';
+import PropTypes from 'prop-types';
+export declare class Likert extends React.Component {
+    static propTypes: {
+        className: PropTypes.Requireable<string>;
+        choices: PropTypes.Requireable<any[]>;
+        prompt: PropTypes.Requireable<string>;
+        teacherInstructions: PropTypes.Requireable<string>;
+        session: PropTypes.Requireable<object>;
+        disabled: PropTypes.Validator<boolean>;
+        onSessionChange: PropTypes.Validator<(...args: any[]) => any>;
+        likertOrientation: PropTypes.Validator<string>;
+    };
+    UNSAFE_componentWillReceiveProps(): void;
+    isSelected(value: any): any;
+    render(): React.JSX.Element;
+}
+export default Likert;

package/dist/delivery/likert.js

@@ -0,0 +1,70 @@
+import { LIKERT_ORIENTATION as e } from "./likertEntities.js";
+import t from "./choice-input.js";
+import n from "react";
+import r from "prop-types";
+import * as i from "@pie-lib/render-ui";
+import { Collapsible as a, PreviewPrompt as o, color as s } from "@pie-lib/render-ui";
+import { jsx as c, jsxs as l } from "react/jsx-runtime";
+import { styled as u } from "@mui/material/styles";
+//#region src/delivery/likert.tsx
+function d(e) {
+	return typeof e == "function" || typeof e == "object" && !!e && typeof e.$$typeof == "symbol";
+}
+function f(e, t) {
+	return !e || d(e) ? e : d(e.default) ? e.default : t && d(e[t]) ? e[t] : t && d(e[t]?.default) ? e[t].default : e;
+}
+var p = f(o, "PreviewPrompt") || f(_.PreviewPrompt, "PreviewPrompt"), m = f(a, "Collapsible") || f(_.Collapsible, "Collapsible"), h = i, g = h.default, _ = g && typeof g == "object" ? g : h, v = u("div")({
+	color: s.text(),
+	backgroundColor: s.background(),
+	"& *": { "-webkit-font-smoothing": "antialiased" }
+}), y = u(m)(({ theme: e }) => ({ marginBottom: e.spacing(2) })), b = u("div")(({ theme: e }) => ({
+	verticalAlign: "middle",
+	color: "var(--pie-primary-text, var(--pie-text, #000000))",
+	paddingBottom: e.spacing(2)
+})), x = u("div")({ display: "flex" }), S = class extends n.Component {
+	static propTypes = {
+		className: r.string,
+		choices: r.array,
+		prompt: r.string,
+		teacherInstructions: r.string,
+		session: r.object,
+		disabled: r.bool.isRequired,
+		onSessionChange: r.func.isRequired,
+		likertOrientation: r.string.isRequired
+	};
+	UNSAFE_componentWillReceiveProps() {}
+	isSelected(e) {
+		return this.props.session && this.props.session.value === e;
+	}
+	render() {
+		let { disabled: n, choices: r = [], prompt: i, onSessionChange: a, teacherInstructions: o, className: s, likertOrientation: u } = this.props, d = u === e.vertical ? "column" : "row";
+		return /* @__PURE__ */ l(v, {
+			className: s,
+			children: [
+				o && /* @__PURE__ */ c(y, {
+					labels: {
+						hidden: "Show Teacher Instructions",
+						visible: "Hide Teacher Instructions"
+					},
+					children: /* @__PURE__ */ c(p, { prompt: o })
+				}),
+				i && /* @__PURE__ */ c(b, { children: /* @__PURE__ */ c(p, { prompt: i }) }),
+				/* @__PURE__ */ c(x, {
+					style: { flexDirection: d },
+					children: r.map((e, r) => /* @__PURE__ */ c(t, {
+						label: e.label,
+						value: e.value,
+						index: r,
+						disabled: n,
+						onChange: a,
+						likertOrientation: u,
+						checked: this.isSelected(e.value)
+					}, `choice-${r}`))
+				})
+			]
+		});
+	}
+};
+S.defaultProps = { session: { value: [] } };
+//#endregion
+export { S as default };

package/dist/delivery/likertEntities.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @synced-from pie-elements/packages/likert/src/likertEntities.js
+ * @auto-generated
+ *
+ * This file is automatically synced from pie-elements and converted to TypeScript.
+ * Manual edits will be overwritten on next sync.
+ * To make changes, edit the upstream JavaScript file and run sync again.
+ */
+export declare const LIKERT_ORIENTATION: {
+    horizontal: string;
+    vertical: string;
+};

package/dist/delivery/likertEntities.js

@@ -0,0 +1,7 @@
+//#region src/delivery/likertEntities.ts
+var e = {
+	horizontal: "horizontal",
+	vertical: "vertical"
+};
+//#endregion
+export { e as LIKERT_ORIENTATION };

package/dist/delivery/main.d.ts

@@ -0,0 +1,23 @@
+/**
+ * @synced-from pie-elements/packages/likert/src/main.jsx
+ * @auto-generated
+ *
+ * This file is automatically synced from pie-elements and converted to TypeScript.
+ * Manual edits will be overwritten on next sync.
+ * To make changes, edit the upstream JavaScript file and run sync again.
+ */
+import React from 'react';
+import PropTypes from 'prop-types';
+declare class Main extends React.Component {
+    static propTypes: {
+        model: PropTypes.Requireable<object>;
+        session: PropTypes.Requireable<object>;
+        onSessionChange: PropTypes.Requireable<(...args: any[]) => any>;
+    };
+    static defaultProps: {
+        model: {};
+        session: {};
+    };
+    render(): React.JSX.Element;
+}
+export default Main;