@slicemachine/manager 0.0.0-alpha.dev-new-release-process.1

package/src/lib/installDependencies.ts

@@ -0,0 +1,65 @@
+import { parseNi } from "@antfu/ni";
+import {
+	ExecaChildProcess,
+	execaCommand,
+	Options as ExacaOptions,
+} from "execa";
+
+import { PackageManager } from "../types";
+
+const EXTRA_INSTALL_FLAGS: Record<PackageManager, string[]> = {
+	npm: ["--color=always", "--loglevel=info"], // Default: `--color=true --loglevel=notice`.
+	pnpm: [], // Default: `--color=auto --loglevel=info`.
+	yarn: [], // TODO: Add the correct options.
+	"yarn@berry": [], // TODO: Add the correct options.
+	"pnpm@6": [], // // TODO: Add the correct options.
+	bun: [], // TODO: Add the correct options.
+};
+
+type InstallDependenciesArgs = {
+	packageManager: PackageManager;
+	dependencies: Record<string, string>;
+	dev?: boolean;
+	execa?: ExacaOptions;
+};
+
+type InstallDependenciesReturnType = {
+	execaProcess: ExecaChildProcess;
+};
+
+export const installDependencies = async (
+	args: InstallDependenciesArgs,
+): Promise<InstallDependenciesReturnType> => {
+	const commandArgs = Object.entries(args.dependencies).map(
+		([pkg, range]) => `${pkg}@${range}`,
+	);
+
+	if (commandArgs.length && args.dev) {
+		commandArgs.unshift("-D");
+	}
+
+	commandArgs.push(...EXTRA_INSTALL_FLAGS[args.packageManager]);
+
+	const command = await parseNi(args.packageManager, commandArgs);
+
+	if (!command) {
+		throw new Error(
+			"Failed to begin dependency installation (could not parse command)",
+			{
+				cause: {
+					packageManager: args.packageManager,
+					dependencies: args.dependencies,
+				},
+			},
+		);
+	}
+
+	const execaProcess = execaCommand(command, {
+		encoding: "utf-8",
+		...args.execa,
+	});
+
+	return {
+		execaProcess,
+	};
+};

package/src/lib/locateFileUpward.ts

@@ -0,0 +1,53 @@
+import * as path from "node:path";
+import * as fs from "node:fs/promises";
+
+import { castArray } from "./castArray";
+
+type LocateFileUpwardConfig = {
+	startDir?: string;
+	stopDir?: string;
+	/**
+	 * @internal
+	 */
+	_originalStartDir?: string;
+};
+
+export const locateFileUpward = async (
+	filePathOrPaths: string | readonly string[],
+	{
+		startDir = process.cwd(),
+		stopDir = path.resolve(startDir, "/"),
+		_originalStartDir,
+	}: LocateFileUpwardConfig = {},
+): Promise<string> => {
+	const originalStartDir = _originalStartDir ?? startDir;
+
+	const filePaths = castArray(filePathOrPaths);
+
+	for (const filePath of filePaths) {
+		const resolvedFilePath = path.resolve(startDir, filePath);
+		try {
+			await fs.access(resolvedFilePath);
+
+			return resolvedFilePath;
+		} catch {
+			continue;
+		}
+	}
+
+	if (startDir === stopDir) {
+		const formattedFilePaths = filePaths
+			.map((filePath) => "`" + filePath + "`")
+			.join(" or ");
+
+		throw new Error(
+			`Could not locate ${formattedFilePaths} between \`${originalStartDir}\` and \`${stopDir}\`.`,
+		);
+	}
+
+	return locateFileUpward(filePathOrPaths, {
+		startDir: path.resolve(startDir, ".."),
+		stopDir,
+		_originalStartDir: originalStartDir,
+	});
+};

package/src/lib/markdownToHTML.ts

@@ -0,0 +1,116 @@
+import type { Plugin, Processor } from "unified";
+import type { Root, ElementContent } from "hast";
+import type { Grammar } from "@wooorm/starry-night";
+import { visit } from "unist-util-visit";
+
+type RehypeStarryNightOptions = {
+	grammars?: Grammar[];
+};
+
+/**
+ * Rehype plugin to highlight code with `starry-night`.
+ *
+ * Adapted from:
+ * https://github.com/wooorm/starry-night/tree/c73aac7b8bff41ada86747f668dd932a791b851b#example-integrate-with-unified-remark-and-rehype
+ */
+const createRehypeStarryNight = async (): Promise<
+	Plugin<[options?: RehypeStarryNightOptions], Root>
+> => {
+	const { createStarryNight, common } = await import("@wooorm/starry-night");
+	const { default: tsxGrammar } = await import(
+		"@wooorm/starry-night/lang/source.tsx.js"
+	);
+	const { default: vueGrammar } = await import(
+		"@wooorm/starry-night/lang/text.html.vue.js"
+	);
+	const { toString } = await import("hast-util-to-string");
+
+	return (options = {}) => {
+		const grammars = options.grammars || [...common, tsxGrammar, vueGrammar];
+		const starryNightPromise = createStarryNight(grammars);
+		const prefix = "language-";
+
+		return async (tree) => {
+			const starryNight = await starryNightPromise;
+
+			visit(tree, "element", function (node, index, parent) {
+				if (!parent || index === null || node.tagName !== "pre") {
+					return;
+				}
+
+				const head = node.children[0];
+
+				if (
+					!head ||
+					head.type !== "element" ||
+					head.tagName !== "code" ||
+					!head.properties
+				) {
+					return;
+				}
+
+				const classes = head.properties.className;
+
+				if (!Array.isArray(classes)) {
+					return;
+				}
+
+				const language = classes.find(
+					(d) => typeof d === "string" && d.startsWith(prefix),
+				);
+
+				if (typeof language !== "string") {
+					return;
+				}
+
+				const scope = starryNight.flagToScope(language.slice(prefix.length));
+
+				// Maybe warn?
+				if (!scope) {
+					return;
+				}
+
+				const fragment = starryNight.highlight(toString(head), scope);
+				const children = fragment.children as ElementContent[];
+
+				parent.children.splice(index, 1, {
+					type: "element",
+					tagName: "div",
+					properties: {
+						className: [
+							"highlight",
+							"highlight-" + scope.replace(/^source\./, "").replace(/\./g, "-"),
+						],
+					},
+					children: [
+						{ type: "element", tagName: "pre", properties: {}, children },
+					],
+				});
+			});
+		};
+	};
+};
+
+let processor: Processor;
+
+export const markdownToHTML = async (markdown: string): Promise<string> => {
+	if (!processor) {
+		const { unified } = await import("unified");
+		const remarkParse = await import("remark-parse");
+		const remarkGfm = await import("remark-gfm");
+		const remarkRehype = await import("remark-rehype");
+		const rehypeStringify = await import("rehype-stringify");
+		const rehypeStarryNight = await createRehypeStarryNight();
+
+		processor = unified()
+			.use(remarkParse.default)
+			.use(remarkGfm.default)
+			.use(remarkRehype.default)
+			.use(rehypeStarryNight)
+			.use(rehypeStringify.default);
+	}
+
+	const virtualFile = await processor.process(markdown);
+
+	return virtualFile.toString();
+};

package/src/lib/mockSlice.ts

@@ -0,0 +1,50 @@
+import { SharedSliceMock } from "@prismicio/mocks";
+
+import { SharedSliceContent } from "@prismicio/types-internal/lib/content";
+import {
+	SharedSlice,
+	SliceDiff,
+} from "@prismicio/types-internal/lib/customtypes";
+
+type mockSliceArgs = {
+	model: SharedSlice;
+	mocks?: SharedSliceContent[];
+	diff?: SliceDiff;
+};
+
+export const mockSlice = (args: mockSliceArgs): SharedSliceContent[] => {
+	const { model, mocks, diff } = args;
+
+	return model.variations.map((variation) => {
+		const variationMock = mocks?.find((m) => m.variation === variation.id);
+
+		const mockConfig = {
+			type: "SharedSlice",
+			variation: variation.id,
+		} as const;
+
+		if (!variationMock) {
+			return SharedSliceMock.generate(model, mockConfig);
+		}
+		if (!diff) {
+			return variationMock;
+		}
+
+		// Enforce at least one item to be created if none are present and variation has item fields
+		if (
+			Object.keys(variation.items || {}).length &&
+			variationMock.items.length === 0
+		) {
+			variationMock.items.push({ __TYPE__: "GroupItemContent", value: [] });
+		}
+		const patched = SharedSliceMock.patch(diff, variationMock, mockConfig);
+		if (!patched.ok) {
+			return variationMock;
+		}
+		if (!patched.result) {
+			return SharedSliceMock.generate(model, mockConfig);
+		}
+
+		return patched.result;
+	});
+};

package/src/lib/prismicrc.ts

@@ -0,0 +1,64 @@
+import * as path from "node:path";
+import * as t from "io-ts";
+import * as rc9 from "rc9";
+
+import { decode } from "./decode";
+
+const PRISMICRC = ".prismicrc";
+
+const Prismicrc = t.partial({
+	telemetry: t.boolean,
+});
+type Prismicrc = t.TypeOf<typeof Prismicrc>;
+
+export const readRawPrismicrc = (dir?: string): Prismicrc => {
+	const rawPrismicrc = dir
+		? rc9.read({ dir, name: PRISMICRC })
+		: rc9.readUser(PRISMICRC);
+
+	const { value: prismicrc, error } = decode(Prismicrc, rawPrismicrc);
+
+	if (error) {
+		throw new Error(
+			`Failed to parse ${
+				dir ? path.resolve(dir, PRISMICRC) : `~/${PRISMICRC}`
+			}: ${error.errors.join(", ")}`,
+		);
+	}
+
+	return prismicrc;
+};
+
+export const readPrismicrc = (dir: string): Prismicrc => {
+	const userPrismicrc = readRawPrismicrc();
+	const projectPrismicrc = readRawPrismicrc(dir);
+
+	return {
+		...userPrismicrc,
+		...projectPrismicrc,
+	};
+};
+
+export const writePrismicrc = (config: Prismicrc, dir?: string): void => {
+	const { value: validatedConfig, error } = decode(Prismicrc, config);
+
+	if (error) {
+		throw new Error(`Failed to validate config: ${error.errors.join(", ")}`);
+	}
+
+	dir
+		? rc9.write(validatedConfig, { dir, name: PRISMICRC })
+		: rc9.writeUser(validatedConfig, PRISMICRC);
+};
+
+export const updatePrismicrc = (config: Prismicrc, dir?: string): Prismicrc => {
+	const { value: validatedConfig, error } = decode(Prismicrc, config);
+
+	if (error) {
+		throw new Error(`Failed to validate config: ${error.errors.join(", ")}`);
+	}
+
+	return dir
+		? rc9.update(validatedConfig, { dir, name: PRISMICRC })
+		: rc9.updateUser(validatedConfig, PRISMICRC);
+};

package/src/lib/serializeCookies.ts

@@ -0,0 +1,45 @@
+import cookie from "cookie";
+
+const COOKIE_SEPARATOR = "; ";
+
+type Cookies = string | string[] | Record<string, string>;
+
+const castParsedCookies = (cookies: Cookies): Record<string, string> => {
+	if (Array.isArray(cookies)) {
+		return cookie.parse(cookies.join(COOKIE_SEPARATOR));
+	} else if (typeof cookies === "string") {
+		return cookie.parse(cookies);
+	} else {
+		return cookies;
+	}
+};
+
+type SerializeCookiesArgs = {
+	cookieJar?: Cookies;
+};
+
+// TODO: If the `cookieJar` and multiple input types are not used anywhere,
+// simplify this function to only serialize a given object of cookies into a
+// string.
+export const serializeCookies = (
+	cookies: Cookies,
+	args: SerializeCookiesArgs = {},
+): string => {
+	const cookiesToSerialize = {
+		...castParsedCookies(args.cookieJar || {}),
+		...castParsedCookies(cookies),
+	};
+
+	const items: string[] = [];
+
+	for (const name in cookiesToSerialize) {
+		items.push(
+			cookie.serialize(name, cookiesToSerialize[name], {
+				// Cookies need be stored raw (not encoded or escaped), so that consumers can format them the way they want them to be formatted.
+				encode: (cookie) => cookie,
+			}),
+		);
+	}
+
+	return items.join(COOKIE_SEPARATOR);
+};

package/src/lib/trailingSlash.ts

@@ -0,0 +1,9 @@
+export const addTrailingSlash = (
+	url: string | undefined,
+): string | undefined => {
+	return url?.replace(/\/?$/, "/");
+};
+
+export const removeTrailingSlash = (url: string): string => {
+	return url.replace(/\/$/, "");
+};

package/src/managers/BaseManager.ts

@@ -0,0 +1,100 @@
+import { SliceMachinePluginRunner } from "@slicemachine/plugin-kit";
+import { PrismicAuthManager } from "../auth/PrismicAuthManager";
+
+import { SliceMachineManager } from "./SliceMachineManager";
+
+import { UserManager } from "./user/UserManager";
+import { PrismicRepositoryManager } from "./prismicRepository/PrismicRepositoryManager";
+
+import { PluginsManager } from "./plugins/PluginsManager";
+
+import { ProjectManager } from "./project/ProjectManager";
+import { CustomTypesManager } from "./customTypes/CustomTypesManager";
+import { SlicesManager } from "./slices/SlicesManager";
+import { SnippetsManager } from "./snippets/SnippetsManager";
+import { ScreenshotsManager } from "./screenshots/ScreenshotsManager";
+import { SimulatorManager } from "./simulator/SimulatorManager";
+
+import { VersionsManager } from "./versions/VersionsManager";
+import { TelemetryManager } from "./telemetry/TelemetryManager";
+import { DocumentationManager } from "./documentation/DocumentationManager";
+import { SliceTemplateLibraryManager } from "./sliceTemplateLibrary/SliceTemplateLibraryManager";
+
+export abstract class BaseManager {
+	private _sliceMachineManager: SliceMachineManager;
+
+	constructor(sliceMachineManager: SliceMachineManager) {
+		this._sliceMachineManager = sliceMachineManager;
+	}
+
+	protected get prismicAuthManager(): PrismicAuthManager {
+		return this._sliceMachineManager.getPrismicAuthManager();
+	}
+
+	protected get sliceMachinePluginRunner():
+		| SliceMachinePluginRunner
+		| undefined {
+		return this._sliceMachineManager.getSliceMachinePluginRunner();
+	}
+
+	protected set sliceMachinePluginRunner(
+		sliceMachinePluginRunner: SliceMachinePluginRunner | undefined,
+	) {
+		// @ts-expect-error - _sliceMachinePluginRunner is private. We
+		// are intentially ignoring its privacy to allow Manager
+		// classes to access a shared plugin runner via protected
+		// getters and setters.
+		this._sliceMachineManager._sliceMachinePluginRunner =
+			sliceMachinePluginRunner;
+	}
+
+	protected get cwd(): string {
+		return this._sliceMachineManager.cwd;
+	}
+
+	// Protected instance prevents circular intellisense
+	// e.g. sliceMachineManager.user.user.user
+	protected get user(): UserManager {
+		return this._sliceMachineManager.user;
+	}
+	protected get prismicRepository(): PrismicRepositoryManager {
+		return this._sliceMachineManager.prismicRepository;
+	}
+
+	protected get plugins(): PluginsManager {
+		return this._sliceMachineManager.plugins;
+	}
+
+	protected get project(): ProjectManager {
+		return this._sliceMachineManager.project;
+	}
+	protected get customTypes(): CustomTypesManager {
+		return this._sliceMachineManager.customTypes;
+	}
+	protected get slices(): SlicesManager {
+		return this._sliceMachineManager.slices;
+	}
+	protected get snippets(): SnippetsManager {
+		return this._sliceMachineManager.snippets;
+	}
+	protected get screenshots(): ScreenshotsManager {
+		return this._sliceMachineManager.screenshots;
+	}
+	protected get simulator(): SimulatorManager {
+		return this._sliceMachineManager.simulator;
+	}
+	protected get documentation(): DocumentationManager {
+		return this._sliceMachineManager.documentation;
+	}
+	protected get sliceTemplateLibrary(): SliceTemplateLibraryManager {
+		return this._sliceMachineManager.sliceTemplateLibrary;
+	}
+
+	protected get versions(): VersionsManager {
+		return this._sliceMachineManager.versions;
+	}
+
+	protected get telemetry(): TelemetryManager {
+		return this._sliceMachineManager.telemetry;
+	}
+}