@persona/layout-editor-remote-module 0.0.0-bootstrap.0 → 0.5.0

package/dist/protocol-DMsysRFd.mjs

@@ -0,0 +1,211 @@
+import { z } from "zod";
+
+//#region src/bridge/origin.ts
+const dashboardHostOriginPattern = /^https:\/\/([a-z0-9-]+\.)*withpersona(-staging)?\.com$/;
+const pagesHostOriginPattern = /^https:\/\/[a-z0-9-]+\.persona-web\.pages\.dev$/;
+const coderHostOriginPattern = /^https:\/\/[a-z0-9-]+\.coder\.development\.personerds\.com$/;
+const localHostOriginPattern = /^http:\/\/(?:localhost|127\.0\.0\.1):\d+$/;
+function personaDashboardHostOrigins(origin) {
+	return dashboardHostOriginPattern.test(origin) || pagesHostOriginPattern.test(origin) || coderHostOriginPattern.test(origin) || localHostOriginPattern.test(origin);
+}
+function resolveAllowedHostOrigins(allowedHostOrigins) {
+	if (allowedHostOrigins === void 0) return personaDashboardHostOrigins;
+	if (typeof allowedHostOrigins === "function") return allowedHostOrigins;
+	return (origin) => allowedHostOrigins.some((allowedOrigin) => typeof allowedOrigin === "string" ? allowedOrigin === origin : allowedOrigin.test(origin));
+}
+function candidateParentOrigin() {
+	if (typeof window === "undefined") return;
+	try {
+		const ancestorOrigin = window.location.ancestorOrigins?.[0];
+		if (ancestorOrigin) return ancestorOrigin;
+	} catch {}
+	try {
+		return document.referrer ? new URL(document.referrer).origin : void 0;
+	} catch {
+		return;
+	}
+}
+function assertNotSelfOrigin(moduleOrigin) {
+	if (typeof window !== "undefined" && moduleOrigin === window.location.origin) throw new Error("Remote module origin must not match the host origin");
+}
+
+//#endregion
+//#region src/schema.ts
+/**
+* Mirrors persona-web's `LAYOUT_COLUMN_TOTAL`
+* (front-end/dashboard/modules/lib/constants.ts). The enum schemas below
+* mirror persona-web's corresponding enum values and are kept in sync by hand;
+* this package has no dependency on persona-web.
+*/
+const MAX_GRID_COLUMNS = 12;
+const layoutTypeSchema = z.enum([
+	"account",
+	"case",
+	"transaction"
+]);
+const moduleCategorySchema = z.enum([
+	"build_your_own",
+	"components",
+	"management",
+	"related_records"
+]);
+const moduleBadgeSchema = z.enum([
+	"beta",
+	"deprecated",
+	"improved",
+	"new"
+]);
+/**
+* A manifest `key` is embedded verbatim into a persisted module identity
+* string (`${sourceId}/${key}`) and used in DOM ids and analytics — restrict it
+* to a safe, stable charset up front rather than discovering the hard way that
+* some producer emitted spaces or slashes.
+*/
+const moduleKeySchema = z.string().min(1).regex(/^[a-z0-9_]+$/, "key must be lowercase alphanumeric with underscores only");
+const gridSizeSchema = z.object({
+	height: z.number().int().min(1),
+	width: z.number().int().min(1).max(MAX_GRID_COLUMNS)
+});
+/**
+* `code` (a chunk URL, direct-`import()`ed) and `document` (a page URL, host
+* iframes it instead) are mutually exclusive — a delivery is one or the
+* other, never both, never neither.
+*/
+const remoteDeliverySchema = z.union([z.object({ code: z.string().min(1) }), z.object({ document: z.string().min(1) })]);
+const remoteEntrySchema = z.object({
+	css: z.array(z.string()).optional(),
+	render: remoteDeliverySchema
+});
+/**
+* Loose check shared by `configSchema` and `uiConfigSchema` — this validates
+* the manifest envelope, not the arbitrary object either one carries. Both
+* are trusted structurally (an object) and used for their stated purpose
+* (JSON Schema validation, RJSF ui hints) by the consumer, not re-validated
+* here.
+*/
+const looseObjectSchema = z.record(z.string(), z.unknown());
+const remoteModuleRegistrationManifestV1Schema = z.object({
+	allowAddingToLayout: z.boolean(),
+	allowDynamicHeight: z.boolean().optional(),
+	badge: moduleBadgeSchema.optional(),
+	category: moduleCategorySchema.optional(),
+	configSchema: looseObjectSchema.optional(),
+	defaultSize: z.partialRecord(layoutTypeSchema, gridSizeSchema),
+	descriptionShort: z.string().min(1),
+	displayName: z.string().min(1),
+	icon: z.string().min(1).optional(),
+	internalUsersOnly: z.boolean().optional(),
+	key: moduleKeySchema,
+	layouts: z.array(layoutTypeSchema).default([]),
+	manifestVersion: z.literal("v1"),
+	remote: remoteEntrySchema,
+	uiConfigSchema: looseObjectSchema.optional()
+}).refine((manifest) => manifest.layouts.every((layout) => manifest.defaultSize[layout]), {
+	message: "defaultSize must have an entry for every layout in `layouts`",
+	path: ["defaultSize"]
+});
+
+//#endregion
+//#region src/bridge/protocol.ts
+const SOURCE = "persona-layout-module";
+const PROTOCOL_VERSION = 1;
+const jsonSchema = z.lazy(() => z.union([
+	z.boolean(),
+	z.null(),
+	z.number(),
+	z.string(),
+	z.array(jsonSchema),
+	z.record(z.string(), jsonSchema)
+]));
+const envelopeSchema = {
+	source: z.literal(SOURCE),
+	protocolVersion: z.literal(PROTOCOL_VERSION)
+};
+const requestIdSchema = z.string().min(1);
+const variableMapSchema = z.record(z.string(), z.union([z.string(), z.number()]));
+const readySchema = z.object({
+	...envelopeSchema,
+	type: z.literal("ready")
+}).strict();
+const requestDataSchema = z.object({
+	...envelopeSchema,
+	type: z.literal("request-data"),
+	requestId: requestIdSchema
+}).strict();
+const setHeightSchema = z.object({
+	...envelopeSchema,
+	type: z.literal("set-height"),
+	height: z.number()
+}).strict();
+const renderErrorSchema = z.object({
+	...envelopeSchema,
+	type: z.literal("render-error"),
+	message: z.string()
+}).strict();
+const resolveDataPathSchema = z.object({
+	...envelopeSchema,
+	type: z.literal("resolve-data-path"),
+	requestId: requestIdSchema,
+	dataPath: z.string(),
+	variableMap: variableMapSchema.optional()
+}).strict();
+/**
+* Runtime facts about where the module is rendered, owned by the host and not
+* derivable by the module itself. Distinct from `data`, which is the module's
+* persisted config.
+*/
+const remoteModuleContextSchema = z.object({
+	layoutType: layoutTypeSchema,
+	layoutObjectId: z.string().nullable(),
+	isReadOnly: z.boolean(),
+	isInEditor: z.boolean(),
+	isUsingStubData: z.boolean()
+}).strict();
+const moduleToHostMessageSchema = z.discriminatedUnion("type", [
+	readySchema,
+	requestDataSchema,
+	setHeightSchema,
+	renderErrorSchema,
+	resolveDataPathSchema
+]);
+const initSchema = z.object({
+	...envelopeSchema,
+	type: z.literal("init"),
+	data: jsonSchema,
+	context: remoteModuleContextSchema
+}).strict();
+const dataSchema = z.object({
+	...envelopeSchema,
+	type: z.literal("data"),
+	requestId: requestIdSchema.optional(),
+	data: jsonSchema
+}).strict();
+const contextSchema = z.object({
+	...envelopeSchema,
+	type: z.literal("context"),
+	context: remoteModuleContextSchema
+}).strict();
+const dataPathResultSchema = z.object({
+	...envelopeSchema,
+	type: z.literal("data-path-result"),
+	requestId: requestIdSchema,
+	result: jsonSchema.optional(),
+	error: z.string().optional()
+}).strict().refine(({ result, error }) => result === void 0 !== (error === void 0));
+const hostToModuleMessageSchema = z.discriminatedUnion("type", [
+	initSchema,
+	dataSchema,
+	contextSchema,
+	dataPathResultSchema
+]);
+function parseModuleToHostMessage(data) {
+	const parsed = moduleToHostMessageSchema.safeParse(data);
+	return parsed.success ? parsed.data : null;
+}
+function parseHostToModuleMessage(data) {
+	const parsed = hostToModuleMessageSchema.safeParse(data);
+	return parsed.success ? parsed.data : null;
+}
+
+//#endregion
+export { assertNotSelfOrigin as a, resolveAllowedHostOrigins as c, parseModuleToHostMessage as i, SOURCE as n, candidateParentOrigin as o, parseHostToModuleMessage as r, personaDashboardHostOrigins as s, PROTOCOL_VERSION as t };

package/dist/protocol-edoRdXpF.d.mts

@@ -0,0 +1,30 @@
+import { z } from "zod";
+
+//#region src/types.d.ts
+
+type Json = boolean | JsonObject | JsonValue[] | null | number | string;
+type JsonObject = {
+  [key: string]: Json;
+};
+type JsonValue = Json;
+//#endregion
+//#region src/bridge/protocol.d.ts
+/**
+ * Runtime facts about where the module is rendered, owned by the host and not
+ * derivable by the module itself. Distinct from `data`, which is the module's
+ * persisted config.
+ */
+declare const remoteModuleContextSchema: z.ZodObject<{
+  layoutType: z.ZodEnum<{
+    account: "account";
+    case: "case";
+    transaction: "transaction";
+  }>;
+  layoutObjectId: z.ZodNullable<z.ZodString>;
+  isReadOnly: z.ZodBoolean;
+  isInEditor: z.ZodBoolean;
+  isUsingStubData: z.ZodBoolean;
+}, z.core.$strict>;
+type RemoteModuleContext = z.infer<typeof remoteModuleContextSchema>;
+//#endregion
+export { Json as n, RemoteModuleContext as t };

package/dist/schema-BeI8GdXS.mjs

@@ -0,0 +1,105 @@
+import { z } from "zod";
+
+//#region src/define.ts
+/**
+* Identity function at runtime — it exists to give authors a typed,
+* discoverable way to build a `personaLayoutModules({ modules: [...] })`
+* entry, nothing more. All real work (path resolution, build-graph
+* injection, schema conversion, manifest emission) happens in the Vite
+* plugin, not here.
+*/
+function defineLayoutModule(input) {
+	return input;
+}
+
+//#endregion
+//#region src/manifest-path.ts
+/**
+* Default path (site-root-relative) the manifest document is served from and
+* written to, when `PersonaLayoutModulesOptions.manifestPath` isn't
+* overridden. A standalone module (rather than living in vite-plugin.ts, the
+* one place that actually uses it) so it can also be re-exported from the
+* runtime-safe `.` entry — a consumer wiring up something like CORS for the
+* manifest route in its own server, outside of vite.config.ts, needs this
+* default without pulling in vite/esbuild.
+*/
+const DEFAULT_MANIFEST_PATH = "/_layout_modules_manifest.json";
+
+//#endregion
+//#region src/schema.ts
+/**
+* Mirrors persona-web's `LAYOUT_COLUMN_TOTAL`
+* (front-end/dashboard/modules/lib/constants.ts). The enum schemas below
+* mirror persona-web's corresponding enum values and are kept in sync by hand;
+* this package has no dependency on persona-web.
+*/
+const MAX_GRID_COLUMNS = 12;
+const layoutTypeSchema = z.enum([
+	"account",
+	"case",
+	"transaction"
+]);
+const moduleCategorySchema = z.enum([
+	"build_your_own",
+	"components",
+	"management",
+	"related_records"
+]);
+const moduleBadgeSchema = z.enum([
+	"beta",
+	"deprecated",
+	"improved",
+	"new"
+]);
+/**
+* A manifest `key` is embedded verbatim into a persisted module identity
+* string (`${sourceId}/${key}`) and used in DOM ids and analytics — restrict it
+* to a safe, stable charset up front rather than discovering the hard way that
+* some producer emitted spaces or slashes.
+*/
+const moduleKeySchema = z.string().min(1).regex(/^[a-z0-9_]+$/, "key must be lowercase alphanumeric with underscores only");
+const gridSizeSchema = z.object({
+	height: z.number().int().min(1),
+	width: z.number().int().min(1).max(MAX_GRID_COLUMNS)
+});
+/**
+* `code` (a chunk URL, direct-`import()`ed) and `document` (a page URL, host
+* iframes it instead) are mutually exclusive — a delivery is one or the
+* other, never both, never neither.
+*/
+const remoteDeliverySchema = z.union([z.object({ code: z.string().min(1) }), z.object({ document: z.string().min(1) })]);
+const remoteEntrySchema = z.object({
+	css: z.array(z.string()).optional(),
+	render: remoteDeliverySchema
+});
+/**
+* Loose check shared by `configSchema` and `uiConfigSchema` — this validates
+* the manifest envelope, not the arbitrary object either one carries. Both
+* are trusted structurally (an object) and used for their stated purpose
+* (JSON Schema validation, RJSF ui hints) by the consumer, not re-validated
+* here.
+*/
+const looseObjectSchema = z.record(z.string(), z.unknown());
+const remoteModuleRegistrationManifestV1Schema = z.object({
+	allowAddingToLayout: z.boolean(),
+	allowDynamicHeight: z.boolean().optional(),
+	badge: moduleBadgeSchema.optional(),
+	category: moduleCategorySchema.optional(),
+	configSchema: looseObjectSchema.optional(),
+	defaultSize: z.partialRecord(layoutTypeSchema, gridSizeSchema),
+	descriptionShort: z.string().min(1),
+	displayName: z.string().min(1),
+	icon: z.string().min(1).optional(),
+	internalUsersOnly: z.boolean().optional(),
+	key: moduleKeySchema,
+	layouts: z.array(layoutTypeSchema).default([]),
+	manifestVersion: z.literal("v1"),
+	remote: remoteEntrySchema,
+	uiConfigSchema: looseObjectSchema.optional()
+}).refine((manifest) => manifest.layouts.every((layout) => manifest.defaultSize[layout]), {
+	message: "defaultSize must have an entry for every layout in `layouts`",
+	path: ["defaultSize"]
+});
+
+//#endregion
+export { DEFAULT_MANIFEST_PATH as n, defineLayoutModule as r, remoteModuleRegistrationManifestV1Schema as t };

package/dist/vite-plugin.d.mts

@@ -0,0 +1,43 @@
+import { n as LayoutModuleEntry, r as defineLayoutModule, t as LayoutModuleDefinitionInput } from "./define-Dt8sbrVO.mjs";
+import { Plugin } from "vite";
+
+//#region src/vite-plugin.d.ts
+
+interface PersonaLayoutModulesOptions {
+  /**
+   * Where the manifest document is emitted, relative to the site root — must
+   * include the full JSON file name (e.g. `/manifests/my-app.json`), not just
+   * a directory. Defaults to `DEFAULT_MANIFEST_PATH` (exported from the
+   * package's `.` entry). A leading `/` is optional and stripped if present;
+   * either form resolves to the same path.
+   */
+  manifestPath?: string;
+  /**
+   * Plugins the production build of `code`-delivered layout-module entries
+   * needs (e.g. `react()`, `tailwindcss()`) — called once. These entries are
+   * built via a SEPARATE, isolated `vite.build()` call (see the
+   * `closeBundle` hook), deliberately not part of the app's own build graph
+   * — see its doc comment for why — so the app's own plugin list isn't
+   * inherited automatically. Omit if your modules only need plain TS/JSX
+   * (Vite's built-in esbuild transform already handles that with no plugin).
+   * `document` (`.html`) entries never need this — they run through the
+   * app's own build graph and its own configured plugins directly.
+   */
+  modulePlugins?: () => Plugin[];
+  /** Every module this app registers — passed directly, not discovered. */
+  modules: LayoutModuleDefinitionInput[];
+}
+/**
+ * Vite plugin that takes a statically-declared list of layout modules
+ * (`options.modules`, authored via `defineLayoutModule` — see ./define.ts),
+ * wires every `code`-delivered entry into the build as an addressable ESM
+ * chunk, ensures every `document`-delivered (`.html`) entry is actually
+ * built/served, and emits a `RemoteModuleRegistrationManifestV1[]` document
+ * persona-web can intake.
+ *
+ * Modules are configured directly here, not discovered by globbing the
+ * source tree — a module IS whatever's in `options.modules`, full stop.
+ */
+declare function personaLayoutModules(options: PersonaLayoutModulesOptions): Plugin;
+//#endregion
+export { type LayoutModuleDefinitionInput, type LayoutModuleEntry, PersonaLayoutModulesOptions, defineLayoutModule, personaLayoutModules };