@slicemachine/manager 0.1.1-dev-plugins.3

package/src/lib/fetchNPMPackageVersions.ts

@@ -0,0 +1,46 @@
+import * as t from "io-ts";
+import fetch from "node-fetch";
+
+import { decode } from "./decode";
+
+/**
+ * The Accept header value used when only metadata required for package
+ * installation is needed. The response includes all versions and some of their
+ * metadata.
+ *
+ * @see https://github.com/npm/registry/blob/cfe04736f34db9274a780184d1cdb2fb3e4ead2a/docs/responses/package-metadata.md#package-metadata
+ */
+const NPM_REGISTRY_ABBREVIATED_METADATA_ACCEPT_HEADER =
+	"application/vnd.npm.install-v1+json; q=1.0, application/json; q=0.8, */*";
+
+/**
+ * A minimally defined codec for NPM registry package metadata. Only data needed
+ * for version detection is defined.
+ */
+const NPMRegistryPackageMetadataCodec = t.type({
+	versions: t.UnknownRecord,
+});
+
+type FetchNPMPackageVersionsArgs = {
+	packageName: string;
+};
+
+export const fetchNPMPackageVersions = async (
+	args: FetchNPMPackageVersionsArgs,
+): Promise<string[]> => {
+	const res = await fetch(`https://registry.npmjs.org/${args.packageName}`, {
+		headers: {
+			Accept: NPM_REGISTRY_ABBREVIATED_METADATA_ACCEPT_HEADER,
+		},
+	});
+
+	const json = await res.json();
+
+	const { value, error } = decode(NPMRegistryPackageMetadataCodec, json);
+
+	if (error) {
+		throw new Error(`Invalid NPM registry response.`, { cause: error });
+	}
+
+	return Object.keys(value.versions);
+};

package/src/lib/format.ts

@@ -0,0 +1,34 @@
+import prettier from "prettier";
+import { stripIndent } from "common-tags";
+
+type FormatOptions = {
+	prettier?: prettier.Options;
+	/**
+	 * Determines if a newline is included at the end of the formatted result.
+	 *
+	 * @defaultValue `true`
+	 */
+	includeNewlineAtEnd?: boolean;
+};
+
+export const format = async (
+	source: string,
+	filePath: string,
+	options?: FormatOptions,
+): Promise<string> => {
+	let formatted = stripIndent(source);
+
+	const prettierOptions = await prettier.resolveConfig(filePath);
+
+	formatted = prettier.format(formatted, {
+		...prettierOptions,
+		filepath: filePath,
+		...(options?.prettier ?? {}),
+	});
+
+	if (options?.includeNewlineAtEnd === false) {
+		formatted.replace(/[\r\n]+$/, "");
+	}
+
+	return formatted;
+};

package/src/lib/functionCodec.ts

@@ -0,0 +1,16 @@
+import * as t from "io-ts";
+
+export const functionCodec = new t.Type<
+	// eslint-disable-next-line @typescript-eslint/ban-types
+	Function,
+	// eslint-disable-next-line @typescript-eslint/ban-types
+	Function,
+	unknown
+>(
+	"function",
+	// eslint-disable-next-line @typescript-eslint/ban-types
+	(input: unknown): input is Function => typeof input === "function",
+	(input, context) =>
+		typeof input === "function" ? t.success(input) : t.failure(input, context),
+	t.identity,
+);

package/src/lib/locateFileUpward.ts

@@ -0,0 +1,58 @@
+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("/"),
+		_originalStartDir,
+	}: LocateFileUpwardConfig = {},
+): Promise<string> => {
+	const originalStartDir = _originalStartDir ?? startDir;
+
+	const filePaths = castArray(filePathOrPaths);
+
+	try {
+		for (const filePath of filePaths) {
+			const resolvedFilePath = path.resolve(startDir, filePath);
+
+			try {
+				await fs.access(resolvedFilePath);
+
+				return resolvedFilePath;
+			} catch {
+				continue;
+			}
+		}
+	} catch {
+		// noop
+	}
+
+	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,113 @@
+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 { toString } = await import("hast-util-to-string");
+
+	return (options = {}) => {
+		const grammars = options.grammars || [...common, tsxGrammar];
+		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/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/managers/BaseManager.ts

@@ -0,0 +1,92 @@
+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";
+
+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 versions(): VersionsManager {
+		return this._sliceMachineManager.versions;
+	}
+
+	protected get telemetry(): TelemetryManager {
+		return this._sliceMachineManager.telemetry;
+	}
+}