@slicemachine/adapter-nuxt 0.0.2-dev-plugins-m3.0

package/src/lib/buildSliceLibraryDirectoryPath.ts

@@ -0,0 +1,14 @@
+import { SliceMachineContext } from "@slicemachine/plugin-kit";
+
+import { PluginOptions } from "../types";
+
+type BuildSliceLibraryDirectoryPathArgs = {
+	libraryID: string;
+	helpers: SliceMachineContext<PluginOptions>["helpers"];
+};
+
+export const buildSliceLibraryDirectoryPath = (
+	args: BuildSliceLibraryDirectoryPathArgs,
+): string => {
+	return args.helpers.joinPathFromRoot(args.libraryID);
+};

package/src/lib/checkIsTypeScriptProject.ts

@@ -0,0 +1,17 @@
+import { SliceMachineContext } from "@slicemachine/plugin-kit";
+
+import { PluginOptions } from "../types";
+import { checkPathExists } from "./checkPathExists";
+
+type CheckIsTypeScriptProjectArgs = {
+	helpers: SliceMachineContext<PluginOptions>["helpers"];
+	options: SliceMachineContext<PluginOptions>["options"];
+};
+
+export const checkIsTypeScriptProject = async (
+	args: CheckIsTypeScriptProjectArgs,
+): Promise<boolean> => {
+	const tsConfigPath = args.helpers.joinPathFromRoot("tsconfig.json");
+
+	return args.options.typescript ?? (await checkPathExists(tsConfigPath));
+};

package/src/lib/checkPathExists.ts

@@ -0,0 +1,12 @@
+import * as fs from "node:fs/promises";
+import { PathLike } from "node:fs";
+
+export const checkPathExists = async (path: PathLike): Promise<boolean> => {
+	try {
+		await fs.access(path);
+
+		return true;
+	} catch {
+		return false;
+	}
+};

package/src/lib/isSharedSliceModel.ts

@@ -0,0 +1,14 @@
+import type { SharedSlice } from "@prismicio/types-internal/lib/customtypes";
+
+export const isSharedSliceModel = (
+	// eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types
+	input: any,
+): input is SharedSlice => {
+	return (
+		typeof input === "object" &&
+		input !== null &&
+		"type" in input &&
+		input.type === "SharedSlice" &&
+		typeof input.id === "string"
+	);
+};

package/src/lib/pascalCase.ts

@@ -0,0 +1,12 @@
+import { pascalCase as basePascalCase } from "pascal-case";
+
+/**
+ * Converts a string to a Pascal cased string.
+ *
+ * @param input - String to convert into a Pascal cased string.
+ *
+ * @returns Pascal cased string version of `input`.
+ */
+export const pascalCase = (...input: (string | undefined)[]): string => {
+	return basePascalCase(input.filter(Boolean).join(" "));
+};

package/src/lib/readJSONFile.ts

@@ -0,0 +1,7 @@
+import * as fs from "node:fs/promises";
+
+export const readJSONFile = async <T = unknown>(path: string): Promise<T> => {
+	const contents = await fs.readFile(path, "utf8");
+
+	return JSON.parse(contents);
+};

package/src/lib/rejectIfNecessary.ts

@@ -0,0 +1,16 @@
+export const rejectIfNecessary = <
+	// eslint-disable-next-line @typescript-eslint/no-explicit-any
+	TPromiseSettledResults extends readonly PromiseSettledResult<any>[],
+>(
+	promiseSettledResults: TPromiseSettledResults,
+): void => {
+	const rejectedReasons = promiseSettledResults
+		.filter(
+			(result): result is PromiseRejectedResult => result.status === "rejected",
+		)
+		.map((result) => result.reason);
+
+	if (rejectedReasons.length > 0) {
+		throw rejectedReasons[0];
+	}
+};

package/src/lib/updateSliceModelFile.ts

@@ -0,0 +1,33 @@
+import type { SharedSlice } from "@prismicio/types-internal/lib/customtypes";
+import { SliceMachineContext } from "@slicemachine/plugin-kit";
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+
+import type { PluginOptions } from "../types";
+
+import { buildSliceDirectoryPath } from "./buildSliceDirectoryPath";
+
+type UpdateSliceModelFileArgs = {
+	libraryID: string;
+	model: SharedSlice;
+} & SliceMachineContext<PluginOptions>;
+
+export const updateSliceModelFile = async ({
+	libraryID,
+	model,
+	helpers,
+	options,
+}: UpdateSliceModelFileArgs): Promise<void> => {
+	const filePath = path.join(
+		buildSliceDirectoryPath({ libraryID, model, helpers }),
+		"model.json",
+	);
+
+	let contents = JSON.stringify(model);
+
+	if (options.format) {
+		contents = await helpers.format(contents, filePath);
+	}
+
+	await fs.writeFile(filePath, contents);
+};

package/src/lib/upsertGlobalContentTypes.ts

@@ -0,0 +1,62 @@
+import type { SliceMachineContext } from "@slicemachine/plugin-kit";
+import { generateTypes } from "prismic-ts-codegen";
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+
+import type { PluginOptions } from "../types";
+import { NON_EDITABLE_FILE_BANNER } from "../constants";
+
+/**
+ * Arguments for `upsertGlobalContentTypes()`.
+ */
+type UpsertGlobalTypesArgs = Pick<
+	SliceMachineContext<PluginOptions>,
+	"actions" | "helpers" | "options"
+>;
+
+/**
+ * Creates a globally accessible TypeScript file containing types representing
+ * the Prismic repository's content.
+ */
+export const upsertGlobalContentTypes = async ({
+	actions,
+	helpers,
+	options,
+}: UpsertGlobalTypesArgs): Promise<void> => {
+	const filePath = helpers.joinPathFromRoot("prismicio.d.ts");
+
+	const [customTypeModelDescriptors, sharedSliceModelDescriptors] =
+		await Promise.all([
+			actions.readAllCustomTypeModels(),
+			actions.readAllSliceModels(),
+		]);
+
+	const customTypeModels = customTypeModelDescriptors.map(
+		(customTypeModelDescriptors) => {
+			return customTypeModelDescriptors.model;
+		},
+	);
+	const sharedSliceModels = sharedSliceModelDescriptors.map(
+		(sharedSliceModelDescriptors) => {
+			return sharedSliceModelDescriptors.model;
+		},
+	);
+
+	let contents = generateTypes({
+		customTypeModels,
+		sharedSliceModels,
+		clientIntegration: {
+			includeCreateClientInterface: true,
+			includeContentNamespace: true,
+		},
+	});
+
+	contents = `${NON_EDITABLE_FILE_BANNER}\n\n${contents}`;
+
+	if (options.format) {
+		contents = await helpers.format(contents, filePath);
+	}
+
+	await fs.mkdir(path.dirname(filePath), { recursive: true });
+	await fs.writeFile(filePath, contents);
+};

package/src/lib/upsertSliceLibraryIndexFile.ts

@@ -0,0 +1,90 @@
+import { SliceMachineContext } from "@slicemachine/plugin-kit";
+import { stripIndent } from "common-tags";
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import { NON_EDITABLE_FILE_BANNER } from "../constants";
+
+import { PluginOptions } from "../types";
+
+import { checkIsTypeScriptProject } from "./checkIsTypeScriptProject";
+import { pascalCase } from "./pascalCase";
+import { buildSliceLibraryDirectoryPath } from "./buildSliceLibraryDirectoryPath";
+
+type UpsertSliceLibraryIndexFileArgs = {
+	libraryID: string;
+} & SliceMachineContext<PluginOptions>;
+
+export const upsertSliceLibraryIndexFile = async (
+	args: UpsertSliceLibraryIndexFileArgs,
+): Promise<void> => {
+	const isTypeScriptProject = await checkIsTypeScriptProject({
+		helpers: args.helpers,
+		options: args.options,
+	});
+
+	const filePath = path.join(
+		buildSliceLibraryDirectoryPath({
+			libraryID: args.libraryID,
+			helpers: args.helpers,
+		}),
+		isTypeScriptProject ? "index.ts" : "index.js",
+	);
+
+	const slices = await args.actions.readAllSliceModelsForLibrary({
+		libraryID: args.libraryID,
+	});
+
+	let contents: string;
+
+	if (args.options.lazyLoadSlices) {
+		contents = stripIndent`
+			${NON_EDITABLE_FILE_BANNER}
+
+			import { defineAsyncComponent } from "vue";
+			import { defineSliceZoneComponents } from "@prismicio/vue";
+
+			export const components = defineSliceZoneComponents({
+				${slices
+					.map((slice) => {
+						const id = slice.model.id;
+						const dirName = pascalCase(slice.model.name);
+
+						return `${id}: defineAsyncComponent(() => import("./${dirName}/index.vue"))`;
+					})
+					.join(",\n")}
+			});
+		`;
+	} else {
+		contents = stripIndent`
+			${NON_EDITABLE_FILE_BANNER}
+
+			import { defineSliceZoneComponents } from "@prismicio/vue";
+
+			${slices
+				.map((slice) => {
+					const componentName = pascalCase(slice.model.name);
+					const dirName = pascalCase(slice.model.name);
+
+					return `import ${componentName} from "./${dirName}/index.vue";`;
+				})
+				.join("\n")}
+
+			export const components = defineSliceZoneComponents({
+				${slices
+					.map((slice) => {
+						const id = slice.model.id;
+						const componentName = pascalCase(slice.model.name);
+
+						return `${id}: ${componentName}`;
+					})
+					.join(",\n")}
+			});
+		`;
+	}
+
+	if (args.options.format) {
+		contents = await args.helpers.format(contents, filePath);
+	}
+
+	await fs.writeFile(filePath, contents);
+};

package/src/plugin.ts

@@ -0,0 +1,63 @@
+import { defineSliceMachinePlugin } from "@slicemachine/plugin-kit";
+
+import { name as pkgName } from "../package.json";
+import { PluginOptions } from "./types";
+
+import { projectInit } from "./hooks/project-init";
+import { customTypeAssetDelete } from "./hooks/customType-asset-delete";
+import { customTypeAssetRead } from "./hooks/customType-asset-read";
+import { customTypeAssetUpdate } from "./hooks/customType-asset-update";
+import { customTypeCreate } from "./hooks/customType-create";
+import { customTypeDelete } from "./hooks/customType-delete";
+import { customTypeLibraryRead } from "./hooks/customTypeLibrary-read";
+import { customTypeRead } from "./hooks/customType-read";
+import { customTypeRename } from "./hooks/customType-rename";
+import { customTypeUpdate } from "./hooks/customType-update";
+import { sliceAssetDelete } from "./hooks/slice-asset-delete";
+import { sliceAssetRead } from "./hooks/slice-asset-read";
+import { sliceAssetUpdate } from "./hooks/slice-asset-update";
+import { sliceCreate } from "./hooks/slice-create";
+import { sliceDelete } from "./hooks/slice-delete";
+import { sliceLibraryRead } from "./hooks/sliceLibrary-read";
+import { sliceRead } from "./hooks/slice-read";
+import { sliceRename } from "./hooks/slice-rename";
+import { sliceSimulatorSetupRead } from "./hooks/sliceSimulator-setup-read";
+import { sliceUpdate } from "./hooks/slice-update";
+import { snippetRead } from "./hooks/snippet-read";
+
+export const plugin = defineSliceMachinePlugin<PluginOptions>({
+	meta: {
+		name: pkgName,
+	},
+	defaultOptions: {
+		format: true,
+		lazyLoadSlices: true,
+	},
+	setup({ hook }) {
+		hook("project:init", projectInit);
+
+		hook("slice:create", sliceCreate);
+		hook("slice:update", sliceUpdate);
+		hook("slice:rename", sliceRename);
+		hook("slice:delete", sliceDelete);
+		hook("slice:read", sliceRead);
+		hook("slice:asset:update", sliceAssetUpdate);
+		hook("slice:asset:delete", sliceAssetDelete);
+		hook("slice:asset:read", sliceAssetRead);
+		hook("slice-library:read", sliceLibraryRead);
+
+		hook("custom-type:create", customTypeCreate);
+		hook("custom-type:update", customTypeUpdate);
+		hook("custom-type:rename", customTypeRename);
+		hook("custom-type:delete", customTypeDelete);
+		hook("custom-type:read", customTypeRead);
+		hook("custom-type:asset:update", customTypeAssetUpdate);
+		hook("custom-type:asset:delete", customTypeAssetDelete);
+		hook("custom-type:asset:read", customTypeAssetRead);
+		hook("custom-type-library:read", customTypeLibraryRead);
+
+		hook("snippet:read", snippetRead);
+
+		hook("slice-simulator:setup:read", sliceSimulatorSetupRead);
+	},
+});

package/src/simulator/SliceSimulator.ts

@@ -0,0 +1,157 @@
+import {
+	defineComponent,
+	ref,
+	onMounted,
+	h,
+	PropType,
+	VNodeArrayChildren,
+	AllowedComponentProps,
+	ComponentCustomProps,
+	VNodeProps,
+	onUnmounted,
+} from "vue";
+
+import {
+	getDefaultProps,
+	getDefaultManagedState,
+	getDefaultSlices,
+	getDefaultMessage,
+	onClickHandler,
+	disableEventHandler,
+	simulatorClass,
+	simulatorRootClass,
+	SliceSimulatorProps as BaseSliceSimulatorProps,
+	StateManagerEventType,
+	StateManagerStatus,
+	CoreManager,
+} from "@prismicio/slice-simulator-core";
+
+export type SliceSimulatorProps = Omit<BaseSliceSimulatorProps, "state">;
+
+const coreManager = new CoreManager();
+
+export const SliceSimulatorImpl = /*#__PURE__*/ defineComponent({
+	name: "SliceSimulator",
+	props: {
+		zIndex: {
+			type: Number as PropType<Required<SliceSimulatorProps["zIndex"]>>,
+			default: getDefaultProps().zIndex,
+			required: false,
+		},
+		background: {
+			type: String as PropType<Required<SliceSimulatorProps["background"]>>,
+			default: getDefaultProps().background,
+			required: false,
+		},
+	},
+	setup(props, { slots }) {
+		const managedState = ref(getDefaultManagedState());
+		const slices = ref(getDefaultSlices());
+		const message = ref(getDefaultMessage());
+
+		onMounted(() => {
+			coreManager.stateManager.on(
+				StateManagerEventType.ManagedState,
+				(_managedState) => {
+					managedState.value = _managedState;
+				},
+				"simulator-managed-state",
+			);
+			coreManager.stateManager.on(
+				StateManagerEventType.Slices,
+				(_slices) => {
+					slices.value = _slices;
+				},
+				"simulator-slices",
+			);
+			coreManager.stateManager.on(
+				StateManagerEventType.Message,
+				(_message) => {
+					message.value = _message;
+				},
+				"simulator-message",
+			);
+
+			coreManager.init(getDefaultProps().state);
+		});
+
+		onUnmounted(() => {
+			coreManager.stateManager.off(
+				StateManagerEventType.ManagedState,
+				"simulator-managed-state",
+			);
+
+			coreManager.stateManager.off(
+				StateManagerEventType.Slices,
+				"simulator-slices",
+			);
+
+			coreManager.stateManager.off(
+				StateManagerEventType.Message,
+				"simulator-message",
+			);
+		});
+
+		return () => {
+			const children: VNodeArrayChildren = [];
+
+			if (message.value) {
+				children.push(
+					h("article", {
+						innerHTML: message.value,
+					}),
+				);
+			} else if (slices.value.length && slots.default) {
+				children.push(
+					h(
+						"div",
+						{
+							id: "root",
+							class: simulatorRootClass,
+							style:
+								managedState.value.status !== StateManagerStatus.Loaded
+									? { display: "none" }
+									: undefined,
+							onClickCapture: onClickHandler,
+							onSubmitCapture: disableEventHandler,
+						},
+						[
+							slots.default({
+								slices: slices.value,
+							}),
+						],
+					),
+				);
+			}
+
+			return h(
+				"div",
+				{
+					class: simulatorClass,
+					style: {
+						zIndex: props.zIndex,
+						position: "fixed",
+						top: 0,
+						left: 0,
+						width: "100%",
+						height: "100vh",
+						overflow: "auto",
+						background: props.background,
+					},
+				},
+				children,
+			);
+		};
+	},
+});
+
+// export the public type for h/tsx inference
+// also to avoid inline import() in generated d.ts files
+export const SliceSimulator = SliceSimulatorImpl as unknown as {
+	new (): {
+		$props: AllowedComponentProps &
+			ComponentCustomProps &
+			VNodeProps &
+			SliceSimulatorProps;
+	};
+};

package/src/simulator/index.ts

@@ -0,0 +1,2 @@
+export { SliceSimulator } from "./SliceSimulator";
+export type { SliceSimulatorProps } from "./SliceSimulator";

package/src/types.ts

@@ -0,0 +1,5 @@
+export type PluginOptions = {
+	format?: boolean;
+	lazyLoadSlices?: boolean;
+	typescript?: boolean;
+};