@spacemade/ui 0.0.1

package/src/data/bootstrap.ts

@@ -0,0 +1,196 @@
+import { appConfig } from '@/config/app'
+import { enabledModules } from '@/config/modules'
+import type { BootstrapSnapshot } from '@/types/bootstrap'
+
+export const bootstrapSnapshot: BootstrapSnapshot = {
+  appName: appConfig.name,
+  enabledModules,
+  stats: [
+    { label: 'Core Domains', value: '17' },
+    { label: 'Enabled Modules', value: String(enabledModules.length) },
+    { label: 'Seeded Records', value: '27' },
+    { label: 'Product Tracks', value: '6' },
+  ],
+  domains: [
+    {
+      key: 'projects',
+      title: 'Projects',
+      eyebrow: 'Workspace',
+      description: 'Reusable project scoping and delivery ownership.',
+      href: '/projects',
+      items: [
+        { id: 'proj_website', title: 'Website Platform', meta: 'active', detail: 'Core product shell, auth, navigation, and billing integration.' },
+        { id: 'proj_ops', title: 'Operations Console', meta: 'draft', detail: 'Internal workflows, roles, and service configuration.' },
+      ],
+    },
+    {
+      key: 'providers',
+      title: 'Providers',
+      eyebrow: 'Integrations',
+      description: 'External vendor and service connection registry.',
+      href: '/providers',
+      items: [
+        { id: 'prov_stripe', title: 'Stripe', meta: 'connected', detail: 'Subscriptions, invoices, and payment methods.' },
+        { id: 'prov_resend', title: 'Resend', meta: 'connected', detail: 'Transactional email and invite delivery.' },
+        { id: 'prov_s3', title: 'S3 Storage', meta: 'pending', detail: 'Media and attachment storage.' },
+      ],
+    },
+    {
+      key: 'users',
+      title: 'Users',
+      eyebrow: 'Access',
+      description: 'Account lifecycle and access-role management.',
+      href: '/users',
+      items: [
+        { id: 'usr_1', title: 'Alex Carter', meta: 'owner', detail: 'alex@example.com' },
+        { id: 'usr_2', title: 'Sam Rivera', meta: 'admin', detail: 'sam@example.com' },
+        { id: 'usr_3', title: 'Jordan Lee', meta: 'invited', detail: 'jordan@example.com' },
+      ],
+    },
+    {
+      key: 'orgs',
+      title: 'Organizations',
+      eyebrow: 'Tenant',
+      description: 'Tenant boundaries, plans, and membership counts.',
+      href: '/orgs',
+      items: [
+        { id: 'org_personal', title: 'Personal Workspace', meta: 'Starter plan', detail: '1 member' },
+        { id: 'org_team', title: 'Platform Studio', meta: 'Growth plan', detail: '14 members' },
+      ],
+    },
+    {
+      key: 'products',
+      title: 'Products',
+      eyebrow: 'Billing',
+      description: 'Sellable products and billing parents.',
+      href: '/products',
+      items: [
+        { id: 'prod_admin', title: 'Admin Core', meta: 'subscription', detail: 'Primary recurring product.' },
+        { id: 'prod_launch', title: 'Launch Services', meta: 'one-time', detail: 'Professional services and setup.' },
+      ],
+    },
+    {
+      key: 'subscriptions',
+      title: 'Subscriptions',
+      eyebrow: 'Billing',
+      description: 'Recurring billing relationships and renewal state.',
+      href: '/subscriptions',
+      items: [
+        { id: 'sub_growth', title: 'Growth', meta: 'active', detail: 'Renews on 2026-04-01' },
+      ],
+    },
+    {
+      key: 'invoices',
+      title: 'Invoices',
+      eyebrow: 'Finance',
+      description: 'Invoice lifecycle from draft to paid.',
+      href: '/invoices',
+      items: [
+        { id: 'inv_1', title: 'Invoice inv_1', meta: 'paid', detail: '$199.00 usd' },
+      ],
+    },
+    {
+      key: 'purchases',
+      title: 'Purchases',
+      eyebrow: 'Finance',
+      description: 'One-time orders and payment outcomes.',
+      href: '/purchases',
+      items: [
+        { id: 'pur_1', title: 'Launch Services', meta: 'completed', detail: '$75.00 usd' },
+      ],
+    },
+    {
+      key: 'sites',
+      title: 'Sites',
+      eyebrow: 'Content',
+      description: 'Managed sites and domain-backed properties.',
+      href: '/sites',
+      items: [
+        { id: 'site_docs', title: 'Docs Portal', meta: 'active', detail: 'docs.example.com' },
+      ],
+    },
+    {
+      key: 'posts',
+      title: 'Posts',
+      eyebrow: 'Content',
+      description: 'Structured content entries and publishing state.',
+      href: '/posts',
+      items: [
+        { id: 'post_1', title: 'Launch Checklist', meta: 'published', detail: 'Author: Alex Carter' },
+      ],
+    },
+    {
+      key: 'forms',
+      title: 'Forms',
+      eyebrow: 'Content',
+      description: 'Submission surfaces and intake forms.',
+      href: '/forms',
+      items: [
+        { id: 'form_1', title: 'Contact Sales', meta: 'active', detail: '48 submissions' },
+      ],
+    },
+    {
+      key: 'media',
+      title: 'Media',
+      eyebrow: 'Assets',
+      description: 'File, attachment, and storage records.',
+      href: '/media',
+      items: [
+        { id: 'med_1', title: 'Brand System', meta: 'image', detail: 'Stored in s3' },
+      ],
+    },
+    {
+      key: 'activity',
+      title: 'Activity',
+      eyebrow: 'Ops',
+      description: 'Audit logs and lifecycle events.',
+      href: '/activity',
+      items: [
+        { id: 'act_1', title: 'org.created', meta: 'usr_1', detail: 'Target: org_team' },
+        { id: 'act_2', title: 'invoice.paid', meta: 'usr_2', detail: 'Target: inv_1' },
+      ],
+    },
+    {
+      key: 'tickets',
+      title: 'Tickets',
+      eyebrow: 'Support',
+      description: 'Support operations and issue tracking.',
+      href: '/tickets',
+      items: [
+        { id: 'tkt_1', title: 'Custom domain verification', meta: 'high', detail: 'Assigned to Sam Rivera' },
+      ],
+    },
+    {
+      key: 'usage',
+      title: 'Usage',
+      eyebrow: 'Metering',
+      description: 'Billable consumption and metrics.',
+      href: '/usage',
+      items: [
+        { id: 'usage_1', title: 'api_requests', meta: '182340', detail: '2026-03 requests' },
+      ],
+    },
+    {
+      key: 'tags',
+      title: 'Tags',
+      eyebrow: 'Taxonomy',
+      description: 'Cross-domain labels for content and operations.',
+      href: '/tags',
+      items: [
+        { id: 'tag_ops', title: 'ops', meta: '32 uses', detail: 'Scope: ops' },
+        { id: 'tag_billing', title: 'billing', meta: '18 uses', detail: 'Scope: billing' },
+      ],
+    },
+    {
+      key: 'addresses',
+      title: 'Addresses',
+      eyebrow: 'Shared',
+      description: 'Reusable business and billing addresses.',
+      href: '/addresses',
+      items: [
+        { id: 'addr_1', title: '125 Studio Way', meta: 'Miami, FL', detail: '33101 US' },
+      ],
+    },
+  ],
+  optionalDomains: [],
+}

package/src/data/bootstrapIcons.ts

@@ -0,0 +1,28 @@
+// src/data/bootstrapIcons.ts
+import raw from './bootstrap-icons.json'
+
+// type this loosely so you’re not fighting the exact structure
+type RawIconsJson = Record<
+  string,
+  {
+    name?: string
+    tags?: string[]
+    // …other fields we don’t care about
+  }
+>
+
+export type BootstrapIcon = {
+  id: string          // e.g. 'alarm'
+  label: string       // e.g. 'Alarm'
+  tags: string[]
+}
+
+const rawIcons = raw as RawIconsJson
+
+export const BOOTSTRAP_ICONS: BootstrapIcon[] = Object.entries(rawIcons).map(
+  ([id, meta]) => ({
+    id,
+    label: meta.name || id,
+    tags: meta.tags || [],
+  })
+)

package/src/enum/AppEnvironments.ts

@@ -0,0 +1,4 @@
+export enum AppEnvironments {
+	prod =  'prod',
+	dev =  'dev',
+}

package/src/enum/HTTPErrorStatus.ts

@@ -0,0 +1,10 @@
+export enum HTTPErrorStatus {
+	BAD_REQUEST = 400,
+	UNAUTHORIZED = 401,
+	FORBIDDEN = 403,
+	NOT_FOUND = 404,
+	METHOD_NOT_ALLOWED = 405,
+	CONFLICT = 409,
+	UNPROCESSABLE_ENTITY = 422,
+	INTERNAL_SERVER_ERROR = 500,
+}

package/src/helpers/api/index.ts

@@ -0,0 +1,123 @@
+import { publicRuntimeConfig } from '@config/runtime'
+import { AppEnvironments } from '@enum/AppEnvironments'
+export class APIHelpers {
+	private static getInternalApiHost() {
+		return `http://${process.env.API_HOST || 'api'}:${process.env.API_PORT || '3001'}`
+	}
+
+	static getHost() {
+		const envApiUrl =
+			process.env.NEXT_PUBLIC_API_URL ||
+			process.env.NEXT_PUBLIC_API_HOST
+		if (envApiUrl) return envApiUrl.replace(/\/$/, '')
+		if (typeof window !== 'undefined') {
+			return window.location.origin
+		}
+		if (publicRuntimeConfig.appEnvironment === AppEnvironments.dev) {
+			return APIHelpers.getInternalApiHost()
+		}
+
+		const configuredSiteUrl = process.env.SITE_URL || process.env.NEXT_PUBLIC_SITE_URL
+		if (configuredSiteUrl) return configuredSiteUrl.replace(/\/$/, '')
+
+		return APIHelpers.getInternalApiHost()
+	}
+
+	// This is used when we need to make a call to the API in the Server Side props
+	static getFullBaseApiURL() {
+		const host = APIHelpers.getHost()
+		return `${host}/api`
+	}
+
+	static async get(route: string, headers: HeadersInit) {
+		const resolvedHeaders = new Headers(headers)
+		if (!resolvedHeaders.has('Accept')) {
+			resolvedHeaders.set('Accept', 'application/json')
+		}
+
+		return APIHelpers.request(route, {
+			credentials: 'include',
+			headers: resolvedHeaders,
+		})
+	}
+
+	static async post(route: string, body: Object, headers: HeadersInit) {
+		const resolvedHeaders = new Headers(headers)
+		if (!resolvedHeaders.has('Accept')) {
+			resolvedHeaders.set('Accept', 'application/json')
+		}
+		if (!resolvedHeaders.has('Content-Type')) {
+			resolvedHeaders.set('Content-Type', 'application/json; charset=UTF-8')
+		}
+
+		return APIHelpers.request(route, {
+			method: 'POST',
+			body: JSON.stringify(body),
+			credentials: 'include',
+			headers: resolvedHeaders,
+		})
+	}
+
+	private static async request(route: string, init: RequestInit) {
+		try {
+			const rawResponse = await fetch(
+				`${APIHelpers.getFullBaseApiURL() + route}`,
+				init
+			)
+			return await APIHelpers.parseResponse(rawResponse)
+		} catch (error) {
+			return APIHelpers.buildNetworkError(route, error)
+		}
+	}
+
+	private static async parseResponse(rawResponse: Response) {
+		const contentType = rawResponse.headers.get('content-type') || ''
+		const text = await rawResponse.text()
+		const isJson = contentType.includes('application/json')
+
+		if (isJson && text) {
+			try {
+				return JSON.parse(text)
+			} catch (error) {
+				return APIHelpers.buildParseError(rawResponse, text, 'Invalid JSON response')
+			}
+		}
+
+		if (!isJson && text) {
+			return APIHelpers.buildParseError(rawResponse, text, 'Non-JSON response')
+		}
+
+		if (!rawResponse.ok) {
+			return APIHelpers.buildParseError(rawResponse, text, 'Request failed')
+		}
+
+		return {}
+	}
+
+	private static buildParseError(rawResponse: Response, text: string, message: string) {
+		const snippet = text.length > 500 ? `${text.slice(0, 500)}...` : text
+		return {
+			error: {
+				status: rawResponse.status,
+				statusText: rawResponse.statusText,
+				message,
+				body: snippet,
+			},
+		}
+	}
+
+	private static buildNetworkError(route: string, error: unknown) {
+		return {
+			error: {
+				status: 503,
+				statusText: 'Service Unavailable',
+				message: 'Network request failed',
+				route,
+				cause: error instanceof Error ? error.message : String(error),
+			},
+		}
+	}
+}
+
+// This is used as base URL for RTK Query
+export const BASE_API_URL = APIHelpers.getFullBaseApiURL()

package/src/helpers/constants/index.ts

@@ -0,0 +1,4 @@
+export * from '@helpers/constants/regex'
+export * from '@helpers/constants/messages'
+export * from '@helpers/constants/stripe'
+export * from '@helpers/constants/system-agent'

package/src/helpers/constants/messages.ts

@@ -0,0 +1 @@
+export const DEFAULT_ERROR_MESSAGE = 'An unexpected error occurred. Please try again later'

package/src/helpers/constants/regex.ts

@@ -0,0 +1,10 @@
+export const PASSWORD_REGEX =
+	/^(?=.{6,})(?=.*[a-z])(?=.*[A-Z])(?=.*[@#$%^&+*!=])(?=.*[0-9])[^\s].*[^\s]$/
+export const EMAIL_REGEX =
+	/^(([^<>()[\]\.,;:\s@\"]+(\.[^<>()[\]\.,;:\s@\"]+)*)|(\".+\"))@(([^<>()[\]\.,;:\s@\"]+\.)+[^<>()[\]\.,;:\s@\"]{2,})$/i
+export const SLUG_REGEX = /^[a-z0-9-]*$/
+export const USERNAME_REGEX = /^[a-z]+([a-zA-Z0-9-_]+)*$/
+export const NUMBER_REGEX = /[0-9]/
+export const GET_FILE_EXTENSION_REGEX = /([0-9a-z]+)(?=[?#])|(?:[\w]+)$/gim
+export const DOMAIN_REFERER_REGEX = /^(?:\*\.|[\w-]+\.)+[a-zA-Z]{2,}$|^localhost$/;
+export const DOMAIN_REGEX = /^(?!:\/\/)([a-zA-Z0-9-]+\.)*[a-zA-Z0-9-]+\.[a-zA-Z]{2,}$/;

package/src/helpers/constants/stripe.ts

@@ -0,0 +1 @@
+export const STRIPE_MINIMUM_AMOUNT_IN_CENTS = 50

package/src/helpers/constants/system-agent.ts

@@ -0,0 +1,12 @@
+const resolveConfigId = (value: string | undefined, fallback: string) =>
+  String(value || '').trim() || fallback
+
+export const SYSTEM_CODE_AGENT_ID = resolveConfigId(
+  process.env.NEXT_PUBLIC_SYSTEM_CODE_AGENT_ID,
+  'ccf92bdd-1f09-4ca5-8fca-21919ef1ebe3'
+)
+
+export const SYSTEM_IMAGE_AGENT_ID = resolveConfigId(
+  process.env.NEXT_PUBLIC_SYSTEM_IMAGE_AGENT_ID,
+  '0aa59fd6-a80f-4c41-9975-f20c9bb0739a'
+)

package/src/helpers/data-transform/bytesToSize.ts

@@ -0,0 +1,8 @@
+export const bytesToSize = (bytes: number) => {
+	const sizes = ['Bytes', 'KB', 'MB', 'GB', 'TB']
+	if (bytes === 0) return 'n/a'
+	const value = Math.floor(Math.log(bytes) / Math.log(1024))
+	const i = value
+	if (i === 0) return `${bytes} ${sizes[i]}`
+	return `${(bytes / 1024 ** i).toFixed(1)} ${sizes[i]}`
+}

package/src/helpers/data-transform/dropzone.ts

@@ -0,0 +1,116 @@
+import isEmpty from 'lodash/isEmpty'
+import { FileRejection } from 'react-dropzone'
+import { MediaType } from '@store/model'
+
+interface RejectionListItem {
+	name: string
+	error: string
+}
+
+interface RejectionList {
+	tooLarge: RejectionListItem[]
+	invalid: RejectionListItem[]
+	unexpected: RejectionListItem[]
+}
+
+enum FileErrors {
+	file_too_large = 'file-too-large',
+	file_invalid_type = 'file-invalid-type',
+	unexpected_error = 'unexpected-error',
+}
+
+export class DropzoneHelper {
+	public static readonly DEFAULT_MAX_SIZE = 50 * 1024 * 1024 // 50MB in bytes
+
+	static generateRejectionList(fileRejections: FileRejection[]) {
+		const fileRejectionLists: RejectionList = {
+			tooLarge: [],
+			invalid: [],
+			unexpected: [],
+		}
+
+		fileRejections.forEach((rejectedFile) => {
+			const isInvalidTypeErrors = rejectedFile.errors.filter(
+				(err) => err.code === FileErrors.file_invalid_type
+			)
+			const isTooLargeErrors = rejectedFile.errors.filter(
+				(err) => err.code === FileErrors.file_too_large
+			)
+
+			if (!isEmpty(isInvalidTypeErrors)) {
+				fileRejectionLists.invalid.push({
+					name: rejectedFile.file.name,
+					error: FileErrors.file_invalid_type,
+				})
+			} else if (!isEmpty(isTooLargeErrors)) {
+				fileRejectionLists.tooLarge.push({
+					name: rejectedFile.file.name,
+					error: FileErrors.file_too_large,
+				})
+			} else {
+				fileRejectionLists.unexpected.push({
+					name: rejectedFile.file.name,
+					error: FileErrors.unexpected_error,
+				})
+			}
+		})
+
+		return fileRejectionLists
+	}
+
+	static generateDropzoneErrorMessage(list: RejectionList, type?: MediaType) {
+		let message = ''
+
+		if (!isEmpty(list.invalid)) {
+			message = DropzoneHelper.generateErrorMessage(
+				list.invalid,
+				FileErrors.file_invalid_type,
+				type
+			)
+		} else if (!isEmpty(list.tooLarge)) {
+			message = DropzoneHelper.generateErrorMessage(
+				list.tooLarge,
+				FileErrors.file_too_large
+			)
+		} else if (!isEmpty(list.unexpected)) {
+			message = DropzoneHelper.generateErrorMessage(
+				list.unexpected,
+				FileErrors.unexpected_error
+			)
+		}
+
+		return message
+	}
+
+	private static getInvalidMessageByType(type: MediaType | null) {
+		const invalidMessageByType = {
+			[MediaType.Image]: 'Only images are allowed',
+			[MediaType.CSV]: 'Only CSV files are allowed',
+			[MediaType.PDF]: 'Only PDF files are allowed',
+			[MediaType.Document]:
+				'Only documents such as .doc, .ppt, .txt files are allowed',
+		}
+
+		return type
+			? invalidMessageByType[type]
+			: 'Only images, and documents such as .pdf, .doc, .csv, .ppt, .txt files are allowed'
+	}
+
+	private static generateErrorMessage(
+		list: RejectionListItem[],
+		errorType: FileErrors,
+		type?: MediaType
+	) {
+		const errorDescriptionMap = {
+			[FileErrors.file_invalid_type]: `invalid. ${DropzoneHelper.getInvalidMessageByType(
+				type || null
+			)}`,
+			[FileErrors.file_too_large]: 'too large',
+			[FileErrors.unexpected_error]: 'had an unexpected error ',
+		}
+
+		return `${list.map((item) => item.name).join(', ')} ${
+			list.length > 1 ? 'are' : 'is'
+		} ${errorDescriptionMap[errorType]}`
+	}
+}

package/src/helpers/data-transform/filterUtils.ts

@@ -0,0 +1,21 @@
+interface Data {
+	id: string
+}
+
+export const ensureNoDuplicateData = <P extends Data>(
+	currentData: P[],
+	newData: P[]
+) => {
+	const currentIds = currentData.map((item) => item.id)
+	return newData.filter((item) => !currentIds.includes(item.id))
+}
+
+export const cleanEmptyValues = (data: { [key: string]: any }) => {
+	Object.keys(data).forEach((key) => {
+		if (data[key] === undefined) {
+			delete data[key]
+		}
+	})
+
+	return data
+}

package/src/helpers/data-transform/index.ts

@@ -0,0 +1,4 @@
+export * from '@helpers/data-transform/stringCaseTransform'
+export * from '@helpers/data-transform/filterUtils'
+export * from '@helpers/data-transform/bytesToSize'
+export * from '@helpers/data-transform/operations'

package/src/helpers/data-transform/operations.ts

@@ -0,0 +1,3 @@
+export const centsToDollars = (amount: number) => {
+	return parseFloat(amount.toString()) / 100
+}

package/src/helpers/data-transform/paging.ts

@@ -0,0 +1,24 @@
+export function getCorrectPageNumber(value: any) {
+	const number = Number(value)
+
+	if (isNaN(number)) {
+		return 1
+	}
+
+	if (number < 1) {
+		return 1
+	}
+
+	return number
+}
+
+export function getCorrectPageLimitNumber(value: any, defaultValue = 10) {
+	const maxLimit = 50
+	const number = Number(value)
+
+	if (isNaN(number)) {
+		return defaultValue
+	}
+
+	return number <= maxLimit ? number : maxLimit
+}

package/src/helpers/data-transform/stringCaseTransform.ts

@@ -0,0 +1,34 @@
+export const isArray = function (array: any): boolean {
+  return Array.isArray(array)
+}
+
+export const isObject = function (obj: any): boolean {
+	return obj === Object(obj) && !isArray(obj) && typeof obj !== 'function'
+}
+
+export const snakeToCamel = (str: string) => {
+  const prefixMatch = str.match(/^_+/)
+  const prefix = prefixMatch ? prefixMatch[0] : ''
+  const rest = str.slice(prefix.length)
+  const camelRest = rest.replace(/(_\w)/g, (k) => k[1].toUpperCase())
+  return `${prefix}${camelRest}`
+}
+
+export const keysToCamel = function (val: any): any {
+  if (isObject(val)) {
+    const n: {[name: string]: unknown} = {}
+
+    Object.keys(val)
+      .forEach((key) => {
+        n[snakeToCamel(key as string)] = keysToCamel(val[key])
+      })
+
+    return n
+  } else if (isArray(val)) {
+    return val.map((index: any) => {
+      return keysToCamel(index)
+    })
+  }
+
+  return val
+}