@spacefast/common 0.0.2

package/dist/utils/generate-space-name.js

@@ -0,0 +1,95 @@
+/**
+ * Generates a whimsical, WordPress-flavored space title.
+ *
+ * The pool mixes WordPress jargon (Codex, Permalink, Gutenberg, Pingback)
+ * with engineering/web adjectives so the output reads like a tiny inside
+ * joke instead of an auto-increment. Users can rename later, so the only
+ * requirement is that two back-to-back calls almost never collide.
+ *
+ * Pool size: 32 × 32 = 1024 combinations. Combined with the collision
+ * handling in `uniqueSpaceSlug`, per-team conflicts are very
+ * unlikely. The generator is intentionally dependency-free so it can be
+ * shared by the control-plane, the CLI, and any future surface.
+ */
+const ADJECTIVES = [
+    "Atomic",
+    "Recursive",
+    "Verbose",
+    "Quantum",
+    "Fractal",
+    "Paginated",
+    "Cached",
+    "Distributed",
+    "Serialized",
+    "Minified",
+    "Gzipped",
+    "Semantic",
+    "Canonical",
+    "Nested",
+    "Inlined",
+    "Anchored",
+    "Kerned",
+    "Monospaced",
+    "Syndicated",
+    "Bootstrapped",
+    "Rendered",
+    "Rasterized",
+    "Pixelated",
+    "Vectorized",
+    "Indexed",
+    "Dithered",
+    "Escaped",
+    "Wrapped",
+    "Hooked",
+    "Templated",
+    "Responsive",
+    "Trackbacked",
+];
+const NOUNS = [
+    "Codex",
+    "Permalink",
+    "Trackback",
+    "Pingback",
+    "Sidebar",
+    "Widget",
+    "Excerpt",
+    "Blockquote",
+    "Taxonomy",
+    "Emoji",
+    "Slug",
+    "Draft",
+    "Shortcode",
+    "Hook",
+    "Filter",
+    "Action",
+    "Feed",
+    "Atom",
+    "Webmention",
+    "Fediverse",
+    "Loop",
+    "Query",
+    "Nonce",
+    "Transient",
+    "Theme",
+    "Cron",
+    "Sitemap",
+    "Gutenberg",
+    "Webhook",
+    "Gravatar",
+    "Reblog",
+    "Opengraph",
+];
+function pickRandom(list) {
+    if (list.length === 0) {
+        throw new Error("generateSpaceName: word list is empty.");
+    }
+    const index = Math.floor(Math.random() * list.length);
+    const value = list[index];
+    if (value === undefined) {
+        throw new Error("generateSpaceName: word list contained a hole.");
+    }
+    return value;
+}
+export function generateSpaceTitle() {
+    return `${pickRandom(ADJECTIVES)} ${pickRandom(NOUNS)}`;
+}

package/dist/utils/git-repository.d.ts

@@ -0,0 +1,5 @@
+export type GitRepositoryProvider = "github" | "gitlab" | "bitbucket" | "git";
+export declare function isGitRepositoryRemote(value: string): boolean;
+export declare function gitProviderFromRepositoryRemote(value: string): GitRepositoryProvider;
+export declare function repositoryFullNameFromGitRemote(value: string): string | null;
+export declare function safeRepositoryUrlFromGitRemote(value: string): string | null;

package/dist/utils/git-repository.js

@@ -0,0 +1,99 @@
+const SCP_LIKE_REMOTE_PATTERN = /^[A-Za-z0-9._-]+@([A-Za-z0-9.-]+):(.+)$/;
+const ALLOWED_URL_PROTOCOLS = new Set(["http:", "https:", "ssh:", "git:", "file:"]);
+function normalizedRemote(value) {
+    const trimmed = value.trim();
+    for (let index = 0; index < trimmed.length; index += 1) {
+        const code = trimmed.charCodeAt(index);
+        if (code <= 32 || code === 127) {
+            return null;
+        }
+    }
+    return trimmed || null;
+}
+function parseGitRemote(value) {
+    const remote = normalizedRemote(value);
+    if (!remote) {
+        return null;
+    }
+    const scpLike = remote.match(SCP_LIKE_REMOTE_PATTERN);
+    if (scpLike) {
+        const hostname = scpLike[1]?.toLowerCase() ?? null;
+        const remotePath = scpLike[2]?.replace(/^\/+/, "") ?? "";
+        return hostname && remotePath ? { hostname, path: remotePath } : null;
+    }
+    try {
+        const url = new URL(remote);
+        if (!ALLOWED_URL_PROTOCOLS.has(url.protocol)) {
+            return null;
+        }
+        if (url.protocol !== "file:" && !url.hostname) {
+            return null;
+        }
+        const remotePath = decodeURIComponent(url.pathname).replace(/^\/+/, "");
+        if (!remotePath) {
+            return null;
+        }
+        return {
+            hostname: url.hostname ? url.hostname.toLowerCase() : null,
+            path: remotePath,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+export function isGitRepositoryRemote(value) {
+    return parseGitRemote(value) !== null;
+}
+export function gitProviderFromRepositoryRemote(value) {
+    const hostname = parseGitRemote(value)?.hostname;
+    if (!hostname)
+        return "git";
+    if (hostname.includes("github"))
+        return "github";
+    if (hostname.includes("gitlab"))
+        return "gitlab";
+    if (hostname.includes("bitbucket"))
+        return "bitbucket";
+    return "git";
+}
+export function repositoryFullNameFromGitRemote(value) {
+    const parsed = parseGitRemote(value);
+    if (!parsed?.hostname) {
+        return null;
+    }
+    const path = parsed.path.replace(/\.git$/, "");
+    return path.includes("/") ? path : null;
+}
+export function safeRepositoryUrlFromGitRemote(value) {
+    const parsed = parseGitRemote(value);
+    if (!parsed) {
+        return null;
+    }
+    const repository = parsed.hostname ? repositoryFullNameFromGitRemote(value) : null;
+    if (parsed.hostname && repository && gitProviderFromRepositoryRemote(value) !== "git") {
+        return `https://${parsed.hostname}/${repository}`;
+    }
+    const remote = normalizedRemote(value);
+    if (!remote) {
+        return null;
+    }
+    try {
+        const url = new URL(remote);
+        if (!ALLOWED_URL_PROTOCOLS.has(url.protocol)) {
+            return null;
+        }
+        if (url.protocol === "file:") {
+            return url.toString();
+        }
+        url.username = "";
+        url.password = "";
+        return url.toString();
+    }
+    catch {
+        if (parsed.hostname && repository) {
+            return `https://${parsed.hostname}/${repository}`;
+        }
+        return null;
+    }
+}

package/dist/utils/guards.d.ts

@@ -0,0 +1 @@
+export declare function isOneOf<const Values extends readonly unknown[]>(values: Values, value: unknown): value is Values[number];

package/dist/utils/guards.js

@@ -0,0 +1,3 @@
+export function isOneOf(values, value) {
+    return values.includes(value);
+}

package/dist/utils/publish-detection.d.ts

@@ -0,0 +1,10 @@
+import type { SpaceConfig } from "../contracts/space-config.js";
+import type { SpaceSettingsPatch } from "./space-config.js";
+export declare function detectSpaFromPaths(paths: Iterable<string>): boolean;
+export declare function detectSpaFallbackFromPaths(paths: Iterable<string>): string | null;
+export type SpaceSettingsFromConfigJson = SpaceSettingsPatch & {
+    title?: string;
+    password?: string | null;
+};
+export declare function parseSpaceSettingsFromConfigJson(raw: string | undefined): SpaceSettingsFromConfigJson | null;
+export declare function spaceConfigFromSettings(base: SpaceConfig | null | undefined, patch: SpaceSettingsPatch): SpaceConfig;

package/dist/utils/publish-detection.js

@@ -0,0 +1,118 @@
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+export function detectSpaFromPaths(paths) {
+    return detectSpaFallbackFromPaths(paths) !== null;
+}
+export function detectSpaFallbackFromPaths(paths) {
+    const normalized = new Set(Array.from(paths, (path) => path.replace(/^\/+/g, "")));
+    if (normalized.has("_redirects")) {
+        return null;
+    }
+    if (normalized.has("_shell.html")) {
+        return "/_shell.html";
+    }
+    if (!normalized.has("index.html")) {
+        return null;
+    }
+    const htmlPages = [...normalized].filter((entry) => entry.endsWith(".html") && entry !== "404.html");
+    if (htmlPages.length > 1) {
+        return null;
+    }
+    const hasSpaAssets = [...normalized].some((entry) => /^assets\/.+\.(js|mjs)$/i.test(entry) ||
+        /^static\/js\/.+\.js$/i.test(entry) ||
+        entry.startsWith("_app/") ||
+        entry.startsWith("_next/static/") ||
+        entry === "asset-manifest.json");
+    return hasSpaAssets ? "/index.html" : null;
+}
+// Parses the legacy-vocabulary keys of a local `.stattic/config.json` file
+// (title/mode/spa/password/viewer). Platform SpaceConfig keys are handled
+// separately by the publish flow.
+export function parseSpaceSettingsFromConfigJson(raw) {
+    if (!raw) {
+        return null;
+    }
+    let parsedJson;
+    try {
+        parsedJson = JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+    if (!isRecord(parsedJson)) {
+        return null;
+    }
+    const settings = {};
+    if (parsedJson.title && typeof parsedJson.title === "string") {
+        settings.title = parsedJson.title;
+    }
+    if (parsedJson.mode === "website" || parsedJson.mode === "files") {
+        settings.mode = parsedJson.mode;
+    }
+    if (typeof parsedJson.spa === "boolean") {
+        settings.spa = parsedJson.spa;
+    }
+    if (parsedJson.password === null || typeof parsedJson.password === "string") {
+        settings.password = parsedJson.password;
+    }
+    if (isRecord(parsedJson.viewer)) {
+        const viewer = {};
+        for (const key of ["title", "description", "ogImagePath"]) {
+            const value = parsedJson.viewer[key];
+            if (value === null || typeof value === "string") {
+                viewer[key] = value;
+            }
+        }
+        if (Object.keys(viewer).length > 0) {
+            settings.viewer = viewer;
+        }
+    }
+    return Object.keys(settings).length > 0 ? settings : null;
+}
+// Compiles the legacy `.stattic/config.json` serving vocabulary (mode/spa/viewer)
+// onto a SpaceConfig overlay. Files mode = directory listing with no index; SPA =
+// the legacy "/index.html" fallback; viewer fields map onto meta. Only the publish flow
+// reads a legacy config.json, so this translation lives beside its parser.
+export function spaceConfigFromSettings(base, patch) {
+    const config = { ...base };
+    if (patch.mode === "files") {
+        config.listing = true;
+        config.index = false;
+    }
+    else if (patch.mode === "website") {
+        delete config.listing;
+        delete config.index;
+    }
+    if (patch.spa === true) {
+        config.fallback = "/index.html";
+    }
+    else if (patch.spa === false) {
+        delete config.fallback;
+    }
+    if (patch.viewer) {
+        const meta = { ...config.meta };
+        const entries = [
+            ["title", patch.viewer.title],
+            ["description", patch.viewer.description],
+            ["image", patch.viewer.ogImagePath],
+        ];
+        for (const [key, value] of entries) {
+            if (value === undefined)
+                continue;
+            if (value === null || value === "") {
+                delete meta[key];
+            }
+            else {
+                meta[key] = value;
+            }
+        }
+        if (Object.keys(meta).length > 0) {
+            config.meta = meta;
+        }
+        else {
+            delete config.meta;
+        }
+    }
+    return config;
+}

package/dist/utils/publish-policy.d.ts

@@ -0,0 +1,69 @@
+import type { ErrorCode } from "../contracts/error-codes.js";
+export declare const MANIFEST_MAX_FILES_CEILING = 100000;
+export declare const MANIFEST_MAX_PATH_BYTES = 1024;
+export declare const MANIFEST_MAX_BODY_BYTES: number;
+export declare const MAX_VERSION_FILE_SIZE_BYTES: number;
+export declare const MAX_VERSION_TOTAL_BYTES: number;
+export declare function normalizePublishPath(relativePath: string): string;
+export declare function publishPathIgnored(relativePath: string): boolean;
+export declare function publishPathIsConvention(relativePath: string): boolean;
+export declare function providerRuntimeFeatureWarnings(paths: readonly string[]): PublishManifestWarning[];
+export type StaticUploadPolicyOptions = {
+    reservedRuntimeControlFiles?: Iterable<string>;
+};
+export type StaticUploadPathViolation = {
+    code: ErrorCode;
+    message: string;
+    path: string;
+};
+export declare function staticUploadPathViolation(path: string, options?: StaticUploadPolicyOptions): StaticUploadPathViolation | null;
+export declare function firstStaticUploadPathViolation(paths: string[], options?: StaticUploadPolicyOptions): StaticUploadPathViolation | null;
+export type PublishManifestCaps = {
+    maxFiles?: number | null | undefined;
+    maxFileBytes?: number | null | undefined;
+};
+export type PublishManifestError = {
+    code: ErrorCode;
+    message: string;
+    details?: Record<string, unknown>;
+};
+export type PublishManifestWarning = {
+    severity: "warning";
+    code: ErrorCode;
+    message: string;
+    path: string;
+};
+export type PublishManifestResult<T extends {
+    path: string;
+    size: number;
+}> = {
+    error: PublishManifestError;
+    files: null;
+    warnings: [];
+} | {
+    error: null;
+    files: T[];
+    warnings: PublishManifestWarning[];
+};
+export declare function resolveManifestFileCap(maxFiles?: number | null): number;
+export declare function validatePublishManifest<T extends {
+    path: string;
+    size: number;
+}>(files: readonly T[], caps?: PublishManifestCaps): PublishManifestResult<T>;
+export declare function freePlanCanUploadPath(filePath: string, options?: {
+    claimedSpace?: boolean;
+}): boolean;
+export declare function freePlanCanUploadContentType(contentType: string | undefined): boolean;
+export declare function filterFreePlanManifest<T extends {
+    path: string;
+    contentType?: string | undefined;
+}>(files: readonly T[], options?: {
+    claimedSpace?: boolean;
+}): {
+    allowed: T[];
+    ignored: string[];
+};
+export declare function filterFreePlanHeaders(content: string): {
+    headers: string | undefined;
+    droppedBasicAuthCount: number;
+};