diff --git a/README.md b/README.md index db42a05..b377fb1 100644 --- a/README.md +++ b/README.md @@ -3,10 +3,8 @@

- [![ci][ci-badge]][ci-url] [![backers][backers-badge]][backers-url] [![sponsors][sponsors-badge]][sponsors-url] - [![docker][docker-badge]][docker-url]
@@ -35,7 +33,11 @@ http://invidget.switchblade.xyz/YOUR_INVITE_CODE_OR_SERVER_ID ### Different language `?language=pt` -![Light theme preview](http://invidget.switchblade.xyz/2FB8wDG?language=pt) +![Portuguese theme preview](http://invidget.switchblade.xyz/2FB8wDG?language=pt) + +### Disable animation `?animation=false` + +![Dark theme preview with no animation](http://invidget.switchblade.xyz/2FB8wDG?animation=false) **⚠ THIS PROJECT IS A WIP!** @@ -44,7 +46,7 @@ http://invidget.switchblade.xyz/YOUR_INVITE_CODE_OR_SERVER_ID - Clone this repo - `npm install` - Run `npm run dev` to get the development server up -- Access it through http://localhost:8080/ +- Access it through http://localhost:8787/ ## String guidelines diff --git a/package-lock.json b/package-lock.json index fc2e149..9c26ae3 100644 --- a/package-lock.json +++ b/package-lock.json @@ -10,12 +10,14 @@ "dependencies": { "discord-api-types": "^0.38.11", "iso-639-1": "^3.1.5", + "opentype.js": "^1.3.4", "react": "^19.1.0", "react-dom": "^19.1.0" }, "devDependencies": { "@cloudflare/vitest-pool-workers": "^0.8.19", "@types/node": "^24.0.1", + "@types/opentype.js": "^1.3.8", "@types/react": "^19.1.8", "@types/react-dom": "^19.1.6", "typescript": "^5.5.2", @@ -1339,6 +1341,13 @@ "undici-types": "~7.8.0" } }, + "node_modules/@types/opentype.js": { + "version": "1.3.8", + "resolved": "https://registry.npmjs.org/@types/opentype.js/-/opentype.js-1.3.8.tgz", + "integrity": "sha512-H6qeTp03jrknklSn4bpT1/9+1xCAEIU2CnjcWPkicJy8A1SKuthanbvoHYMiv79/2W3Xn1XE4gfSJFzt2U3JSw==", + "dev": true, + "license": "MIT" + }, "node_modules/@types/react": { "version": "19.1.8", "resolved": "https://registry.npmjs.org/@types/react/-/react-19.1.8.tgz", @@ -1977,6 +1986,22 @@ "dev": true, "license": "MIT" }, + "node_modules/opentype.js": { + "version": "1.3.4", + "resolved": "https://registry.npmjs.org/opentype.js/-/opentype.js-1.3.4.tgz", + "integrity": "sha512-d2JE9RP/6uagpQAVtJoF0pJJA/fgai89Cc50Yp0EJHk+eLp6QQ7gBoblsnubRULNY132I0J1QKMJ+JTbMqz4sw==", + "license": "MIT", + "dependencies": { + "string.prototype.codepointat": "^0.2.1", + "tiny-inflate": "^1.0.3" + }, + "bin": { + "ot": "bin/ot" + }, + "engines": { + "node": ">= 8.0.0" + } + }, "node_modules/path-to-regexp": { "version": "6.3.0", "resolved": "https://registry.npmjs.org/path-to-regexp/-/path-to-regexp-6.3.0.tgz", @@ -2257,6 +2282,12 @@ "npm": ">=6" } }, + "node_modules/string.prototype.codepointat": { + "version": "0.2.1", + "resolved": "https://registry.npmjs.org/string.prototype.codepointat/-/string.prototype.codepointat-0.2.1.tgz", + "integrity": "sha512-2cBVCj6I4IOvEnjgO/hWqXjqBGsY+zwPmHl12Srk9IXSZ56Jwwmy+66XO5Iut/oQVR7t5ihYdLB0GMa4alEUcg==", + "license": "MIT" + }, "node_modules/strip-literal": { "version": "3.0.0", "resolved": "https://registry.npmjs.org/strip-literal/-/strip-literal-3.0.0.tgz", @@ -2270,6 +2301,12 @@ "url": "https://github.com/sponsors/antfu" } }, + "node_modules/tiny-inflate": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/tiny-inflate/-/tiny-inflate-1.0.3.tgz", + "integrity": "sha512-pkY1fj1cKHb2seWDy0B16HeWyczlJA9/WW3u3c4z/NiWDsO3DOU5D7nhTLE9CF0yXv/QZFY7sEJmj24dK+Rrqw==", + "license": "MIT" + }, "node_modules/tinybench": { "version": "2.9.0", "resolved": "https://registry.npmjs.org/tinybench/-/tinybench-2.9.0.tgz", diff --git a/package.json b/package.json index f9370ca..4b385a5 100644 --- a/package.json +++ b/package.json @@ -1,7 +1,13 @@ { - "name": "invidget-cloudflare-worker", - "version": "0.0.0", - "private": true, + "name": "invidget", + "version": "2.0.0", + "description": "SVG invite widgets that look just like the ones on the Discord client!", + "repository": { + "type": "git", + "url": "git+https://github.com/SwitchbladeBot/invidget.git" + }, + "author": "Switchblade Team", + "license": "MIT", "scripts": { "deploy": "wrangler deploy", "dev": "wrangler dev", @@ -12,6 +18,7 @@ "devDependencies": { "@cloudflare/vitest-pool-workers": "^0.8.19", "@types/node": "^24.0.1", + "@types/opentype.js": "^1.3.8", "@types/react": "^19.1.8", "@types/react-dom": "^19.1.6", "typescript": "^5.5.2", @@ -21,6 +28,7 @@ "dependencies": { "discord-api-types": "^0.38.11", "iso-639-1": "^3.1.5", + "opentype.js": "^1.3.4", "react": "^19.1.0", "react-dom": "^19.1.0" } diff --git a/src/DiscordApi.ts b/src/DiscordApi.ts index d273534..838166c 100644 --- a/src/DiscordApi.ts +++ b/src/DiscordApi.ts @@ -1,33 +1,47 @@ -import { - APIGuildWidget, - APIInvite, -} from 'discord-api-types/v10' +import { APIGuildWidget, APIInvite } from 'discord-api-types/v10'; -const API_BASE_URL = 'https://discord.com/api/v10' -const CDN_BASE_URL = 'https://cdn.discordapp.com' +const API_BASE_URL = 'https://discord.com/api/v10/'; +const CDN_BASE_URL = 'https://cdn.discordapp.com'; + +export type InvidgetInvite = { iconBase64: string } & APIInvite; export default class DiscordApi { - static async getWidget(guildId: string): Promise { - const res = await fetch(`${API_BASE_URL}/guilds/${guildId}/widget.json`) - if (!res.ok) throw new Error(`Failed to fetch widget for guild ${guildId}: ${res.statusText}`) - return res.json() - } - - static async getInvite(inviteCode: string): Promise { - const res = await fetch(`${API_BASE_URL}/invites/${inviteCode}?with_counts=true`) - if (!res.ok) throw new Error(`Failed to fetch invite ${inviteCode}: ${res.statusText}`) - return res.json() - } - - static async fetchIcon(iconUrl: string): Promise { - const res = await fetch(iconUrl) - if (!res.ok) throw new Error(`Failed to fetch icon from ${iconUrl}: ${res.statusText}`) - const arrayBuffer = await res.arrayBuffer() - return Buffer.from(arrayBuffer).toString('base64') - } - - static getIconUrl(guildId: string, iconId: string): string { - const ext = iconId.startsWith('a_') ? '.gif' : '.jpg' - return `${CDN_BASE_URL}/icons/${guildId}/${iconId}${ext}` - } + static async getWidget(guildId: string): Promise { + const res = await fetch(`${API_BASE_URL}/guilds/${guildId}/widget.json`); + if (!res.ok) throw new Error(`Failed to fetch widget for guild ${guildId}: ${res.statusText}`); + return res.json(); + } + + static async getInvite(inviteCode: string, animation: boolean = true): Promise { + const res = await fetch(`${API_BASE_URL}/invites/${inviteCode}?with_counts=true`); + if (!res.ok) throw new Error(`Failed to fetch invite ${inviteCode}: ${res.statusText}`); + + const apiInvite: APIInvite = await res.json(); + + return { + ...apiInvite, + iconBase64: + apiInvite.guild && apiInvite.guild.icon + ? await this.fetchIcon(this.getIconUrl(apiInvite.guild.id, apiInvite.guild.icon, animation)) + : '', + }; + } + + static async fetchIcon(iconUrl: string): Promise { + const res = await fetch(iconUrl); + if (!res.ok) throw new Error(`Failed to fetch icon from ${iconUrl}: ${res.statusText}`); + + const arrayBuffer = await res.arrayBuffer(); + const bytes = new Uint8Array(arrayBuffer); + let binary = ''; + for (let i = 0; i < bytes.byteLength; i++) { + binary += String.fromCharCode(bytes[i]); + } + return btoa(binary); + } + + static getIconUrl(guildId: string, iconId: string, animation: boolean = true): string { + const ext = iconId.startsWith('a_') && animation ? '.gif' : '.png'; + return `${CDN_BASE_URL}/icons/${guildId}/${iconId}${ext}`; + } } diff --git a/src/InviteResolver.ts b/src/InviteResolver.ts index 84e8b5c..5533b86 100644 --- a/src/InviteResolver.ts +++ b/src/InviteResolver.ts @@ -12,8 +12,6 @@ export default class InviteResolver { return match[1]; } - const match = query.match(inviteRegex); - if (!match) throw new Error("Invalid invite URL or code."); - return match[1]; + return query; } } diff --git a/src/components/LegacyTemplate/FeatureBadge.tsx b/src/components/LegacyTemplate/FeatureBadge.tsx new file mode 100644 index 0000000..4b7136d --- /dev/null +++ b/src/components/LegacyTemplate/FeatureBadge.tsx @@ -0,0 +1,29 @@ +import { ReactElement } from 'react'; +import { SERVER_NAME_SIZE } from './const'; +import { LegacyThemeColors } from '../../types/themes'; +import { PARTNER_ICON, SPECIAL_BADGE, VERIFIED_ICON } from '../../const/icons'; +export interface BadgeProps { + hasVerified: boolean; + hasHub: boolean; + hasPartnered: boolean; + themeColors: LegacyThemeColors; +} + +export const FeatureBadge: React.FC = ({ hasVerified, hasHub, hasPartnered, themeColors }) => { + if (hasVerified) { + return ( + + + + + ); + } else if (hasPartnered) { + return ( + + + + + ); + } + return null; +} diff --git a/src/components/LegacyTemplate/Font/TextToSvgRenderer.tsx b/src/components/LegacyTemplate/Font/TextToSvgRenderer.tsx new file mode 100644 index 0000000..77732f0 --- /dev/null +++ b/src/components/LegacyTemplate/Font/TextToSvgRenderer.tsx @@ -0,0 +1,40 @@ +import opentype from 'opentype.js'; + +export type SvgTextOptions = { + fontSize?: number; + x?: number; + y?: number; + fill?: string; + anchor?: 'start' | 'middle' | 'end'; + baseline?: 'top' | 'middle' | 'bottom'; +}; + +export function TextToSvgRenderer({ + font, + text, + options = {}, + ...rest +}: { text: string; font: opentype.Font; options?: SvgTextOptions, } & React.SVGProps) { + const fontSize = options.fontSize ?? 72; + let x = options.x ?? 0; + let y = options.y ?? 0; + const fill = options.fill ?? 'black'; + const anchor = options.anchor ?? 'start'; + const baseline = options.baseline ?? 'bottom'; + + const path = font.getPath(text, 0, 0, fontSize); + const box = path.getBoundingBox(); + const width = box.x2 - box.x1; + const height = box.y2 - box.y1; + + if (anchor === 'middle') x -= width / 2; + else if (anchor === 'end') x -= width; + + if (baseline === 'middle') y += height / 2; + else if (baseline === 'top') y += height; + + const alignedPath = font.getPath(text, x, y, fontSize); + const svgPath = alignedPath.toPathData(2); + + return ; +} diff --git a/src/components/LegacyTemplate/JoinButton.tsx b/src/components/LegacyTemplate/JoinButton.tsx new file mode 100644 index 0000000..fb3a510 --- /dev/null +++ b/src/components/LegacyTemplate/JoinButton.tsx @@ -0,0 +1,37 @@ +import WhitneyMedium from '../../fonts/WhitneyMedium'; +import { LegacyThemeColors } from '../../types/themes'; +import { INVITE_WIDTH, PADDING, BUTTON_WIDTH, ICON_SIZE, BUTTON_HEIGHT, PRESENCE_FONT_SIZE } from './const'; +import { TextToSvgRenderer } from './Font/TextToSvgRenderer'; + +type JoinButtonProps = { + themeColors: LegacyThemeColors; + text: string; +}; + +export default function JoinButton({ themeColors, text }: JoinButtonProps) { + return ( + <> + + + + ); +} diff --git a/src/components/LegacyTemplate/LegacyTemplate.tsx b/src/components/LegacyTemplate/LegacyTemplate.tsx index 696768c..54f6cb5 100644 --- a/src/components/LegacyTemplate/LegacyTemplate.tsx +++ b/src/components/LegacyTemplate/LegacyTemplate.tsx @@ -1,242 +1,166 @@ -import strings from '../../const/strings.json'; import { LanguageCode } from 'iso-639-1'; -import { APIInvite, GuildFeature } from 'discord-api-types/v10'; - -type Locale = { - header: string; - header_hub: string; - online: string; - members: string; - button: string; -}; - -function getLocaleStrings(lang: string) { - return (strings as Record)[lang] || strings.en; -} - -type ThemeVariation = 'dark' | 'light' | string; +import { GuildFeature } from 'discord-api-types/v10'; +import { + INVITE_WIDTH, + INVITE_HEIGHT, + PADDING, + HEADER_FONT_SIZE, + HEADER_LINE_HEIGHT, + ICON_SIZE, + PRESENCE_FONT_SIZE, + SERVER_NAME_SIZE, + SERVER_NAME_LINE_HEIGHT, + SERVER_NAME_MARGIN_BOTTOM, + PRESENCE_DOT_SIZE, + PRESENCE_LINE_HEIGHT, + PRESENCE_DOT_MARGIN_RIGHT, + PRESENCE_TEXT_MARGIN_RIGHT, + COMMON_COLORS, + THEMES, + HEADER_MARGIN_BOTTOM, +} from './const'; +import { ThemeVariation } from '../../types/themes'; +import { getLocaleStrings } from '../../types/language'; +import { FeatureBadge } from './FeatureBadge'; +import JoinButton from './JoinButton'; +import { TextToSvgRenderer } from './Font/TextToSvgRenderer'; +import WhitneyBoldRegular from '../../fonts/WhitneyBoldRegular'; +import WhitneySemibold from '../../fonts/WhitneySemibold'; +import { InvidgetInvite } from '../../DiscordApi'; interface InviteRendererProps { - invite: APIInvite; + invite: InvidgetInvite; language?: LanguageCode; animation?: boolean; theme?: ThemeVariation; } -const INVITE_WIDTH = 400; -const INVITE_HEIGHT = 130; -const PADDING = 20; -const ICON_SIZE = 80; -const BUTTON_WIDTH = 120; -const BUTTON_HEIGHT = 40; -const BUTTON_MARGIN_LEFT = 15; -const HEADER_LINE_HEIGHT = 30; -const HEADER_FONT_SIZE = 22; -const SERVER_NAME_SIZE = 20; -const SERVER_NAME_LINE_HEIGHT = 25; -const SERVER_NAME_MARGIN_BOTTOM = 10; -const PRESENCE_LINE_HEIGHT = 25; -const PRESENCE_FONT_SIZE = 14; -const PRESENCE_DOT_SIZE = 10; -const PRESENCE_DOT_MARGIN_RIGHT = 6; -const PRESENCE_TEXT_MARGIN_RIGHT = 15; -const BADGE_MARGIN_RIGHT = 6; - -// Dummy theme colors and locales (replace with your actual constants) -const COMMON_COLORS = { - background: '#222', - header: '#eee', - serverIcon: '#555', - joinButtonBackground: '#5865F2', - joinButtonText: '#fff', - serverName: '#fff', - online: '#43B581', - members: '#747F8D', - presenceText: '#ccc', - badges: { - VERIFIED: { flowerStar: '#7289DA', icon: '#fff' }, - PARTNERED: { flowerStar: '#FAA61A', icon: '#fff' }, - }, -}; - -const THEMES: Record = { - dark: COMMON_COLORS, - light: { - ...COMMON_COLORS, - background: '#eee', - header: '#111', - serverIcon: '#ccc', - serverName: '#111', - presenceText: '#444', - }, -}; - export default function LegacyTemplate({ invite, language = 'en', animation = true, theme = 'dark' }: InviteRendererProps) { const locale = getLocaleStrings(language); - const themeColors = { ...COMMON_COLORS, ...(THEMES[theme] || THEMES.dark) }; + const themeColors = THEMES[theme] || THEMES.dark; - if (!invite.guild) throw new Error("Invalid invite, Guild is missing") + if (!invite.guild) throw new Error('Invalid invite, Guild is missing'); const hasVerified = invite.guild.features.includes(GuildFeature.Verified); const hasHub = invite.guild.features.includes(GuildFeature.Hub); const hasPartnered = invite.guild.features.includes(GuildFeature.Partnered); - // Format numbers with commas const formatNumber = (num: number) => num.toLocaleString(); - // Extra padding for badges - let extraServerNamePadding = 0; - // Simple badge rendering for example - const renderBadge = () => { - if (hasVerified && hasHub) { - extraServerNamePadding = 22; - return ( - - - {/* Render HUB badge icon paths here */} - {/* Simplified as star */} - - H - - - ); - } else if (hasVerified) { - extraServerNamePadding = 22; - return ( - - - - V - - - ); - } else if (hasPartnered) { - extraServerNamePadding = 22; - return ( - - - - P - - - ); - } - return null; - }; + const allMembersMargin = + PRESENCE_DOT_SIZE + + PRESENCE_DOT_MARGIN_RIGHT + + locale.online.replace('{{count}}', formatNumber(invite.approximate_presence_count ? invite.approximate_presence_count : 0)).length * + 6.29 + // approximate width + PRESENCE_TEXT_MARGIN_RIGHT + + PRESENCE_DOT_SIZE / 2; return ( - {/* Header */} - - {hasHub ? locale.header_hub : locale.header} - - - {/* Content container */} - - {/* Server Icon */} - - - - - - - - - {/* Join Button */} - - - {locale.button} - - - {/* Server Name + Badges */} - - {renderBadge()} - - {invite.guild.name} - - - {/* Presence */} - - - - {locale.online.replace('{{count}}', formatNumber(invite.approximate_presence_count ? invite.approximate_presence_count : 0))} - - - + + + + + + {/* Content container */} + + {/* Server Icon */} + + {invite.guild.icon ? ( + - - {locale.online.replace('{{count}}', formatNumber(invite.approximate_presence_count ? invite.approximate_presence_count : 0))} - + ) : ( + + )} + + + + + + + + {/* Join Button */} + + + + + + {/* Server Name + Badges */} + + + + + + + {/* Presence */} + + + + + + + - + ); } diff --git a/src/components/LegacyTemplate/const.ts b/src/components/LegacyTemplate/const.ts new file mode 100644 index 0000000..c67de11 --- /dev/null +++ b/src/components/LegacyTemplate/const.ts @@ -0,0 +1,64 @@ +import { LegacyThemeColors } from '../../types/themes'; + +export const PADDING = 16; +export const ICON_SIZE = 50; + +export const HEADER_FONT_SIZE = 12; +export const HEADER_LINE_HEIGHT = 16; +export const HEADER_MARGIN_BOTTOM = 12; + +export const SERVER_NAME_SIZE = 16; +export const SERVER_NAME_LINE_HEIGHT = 20; +export const SERVER_NAME_MARGIN_BOTTOM = 2; + +export const PRESENCE_FONT_SIZE = 14; +export const PRESENCE_LINE_HEIGHT = 16; +export const PRESENCE_TEXT_MARGIN_RIGHT = 8; + +export const PRESENCE_DOT_SIZE = 8; +export const PRESENCE_DOT_MARGIN_RIGHT = 4; + +export const INVITE_WIDTH = 430; +export const INVITE_HEIGHT = 110; + +export const BUTTON_WIDTH = 94.75; +export const BUTTON_HEIGHT = 40; +export const BUTTON_MARGIN_LEFT = 10; + +export const BADGE_MARGIN_RIGHT = 8; + +export const COMMON_COLORS: LegacyThemeColors = { + background: '#2f3136', + serverName: '#ffffff', + header: '#b9bbbe', + serverIcon: '#36393f', + acronymText: '#dcddde', + presenceText: '#b9bbbe', + joinButtonBackground: '#3ba55c', + joinButtonText: '#ffffff', + online: '#3ba55c', + members: '#747f8d', + badges: { + PARTNERED: { + flowerStar: '#7289da', + icon: '#ffffff', + }, + VERIFIED: { + flowerStar: '#3ba55c', + icon: '#ffffff', + }, + }, +}; + +export const THEMES: Record = { + dark: COMMON_COLORS, + light: { + ...COMMON_COLORS, + background: '#f2f3f5', + serverName: '#060607', + header: '#4f5660', + serverIcon: '#ffffff', + acronymText: '#2e3338', + presenceText: '#4f5660', + }, +}; diff --git a/src/fonts/WhitneyBoldRegular.ts b/src/fonts/WhitneyBoldRegular.ts new file mode 100644 index 0000000..bc226cc --- /dev/null +++ b/src/fonts/WhitneyBoldRegular.ts @@ -0,0 +1,9 @@ +import opentype from "opentype.js"; +import base64ToArrayBuffer from "../util/base64ToArrayBuffer"; + +const whitneyBoldRegular = +'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' + +const WhitneyBoldRegular = opentype.parse(base64ToArrayBuffer(whitneyBoldRegular)); + +export default WhitneyBoldRegular \ No newline at end of file diff --git a/src/fonts/WhitneyBoldRegular.ttf b/src/fonts/WhitneyBoldRegular.ttf new file mode 100644 index 0000000..972cca2 Binary files /dev/null and b/src/fonts/WhitneyBoldRegular.ttf differ diff --git a/src/fonts/WhitneyBookRegular.ttf b/src/fonts/WhitneyBookRegular.ttf new file mode 100644 index 0000000..59b791c Binary files /dev/null and b/src/fonts/WhitneyBookRegular.ttf differ diff --git a/src/fonts/WhitneyLightRegular.ttf b/src/fonts/WhitneyLightRegular.ttf new file mode 100644 index 0000000..9e6bb64 Binary files /dev/null and b/src/fonts/WhitneyLightRegular.ttf differ diff --git a/src/fonts/WhitneyMedium.ts b/src/fonts/WhitneyMedium.ts new file mode 100644 index 0000000..4087724 --- /dev/null +++ b/src/fonts/WhitneyMedium.ts @@ -0,0 +1,9 @@ +import opentype from "opentype.js"; +import base64ToArrayBuffer from "../util/base64ToArrayBuffer"; + +const whitneyMedium = +'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' + +const WhitneyMedium = opentype.parse(base64ToArrayBuffer(whitneyMedium)); + +export default WhitneyMedium \ No newline at end of file diff --git a/src/fonts/WhitneyMediumRegular.ttf b/src/fonts/WhitneyMediumRegular.ttf new file mode 100644 index 0000000..9d34f7a Binary files /dev/null and b/src/fonts/WhitneyMediumRegular.ttf differ diff --git a/src/fonts/WhitneySemibold.ts b/src/fonts/WhitneySemibold.ts new file mode 100644 index 0000000..f9a03cb --- /dev/null +++ b/src/fonts/WhitneySemibold.ts @@ -0,0 +1,9 @@ +import opentype from "opentype.js"; +import base64ToArrayBuffer from "../util/base64ToArrayBuffer"; + +const whitneySemibold = +'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' + +const WhitneySemibold = opentype.parse(base64ToArrayBuffer(whitneySemibold)); + +export default WhitneySemibold \ No newline at end of file diff --git a/src/fonts/WhitneySemiboldRegular.ttf b/src/fonts/WhitneySemiboldRegular.ttf new file mode 100644 index 0000000..b604ea2 Binary files /dev/null and b/src/fonts/WhitneySemiboldRegular.ttf differ diff --git a/src/index.ts b/src/index.ts index 3f546be..cf719a1 100644 --- a/src/index.ts +++ b/src/index.ts @@ -34,9 +34,11 @@ export default { ...parseQuery(url.searchParams), });*/ + const query = parseQuery(url.searchParams) + const reactElement = React.createElement(LegacyTemplate, { - invite: await DiscordApi.getInvite(inviteCode), - ...parseQuery(url.searchParams), + invite: await DiscordApi.getInvite(inviteCode, query.animation), + ...query, }); const svgString = renderToString(reactElement); diff --git a/src/types/language.d.ts b/src/types/language.d.ts deleted file mode 100644 index c92cf83..0000000 --- a/src/types/language.d.ts +++ /dev/null @@ -1,13 +0,0 @@ -import { LanguageCode } from 'iso-639-1' - -type Locale = { - header: string - header_hub: string - online: string - members: string - button: string -} - -function getLocaleStrings(lang: string) { - return (strings as Record)[lang] || strings.en; -} \ No newline at end of file diff --git a/src/types/language.ts b/src/types/language.ts new file mode 100644 index 0000000..87ad7f1 --- /dev/null +++ b/src/types/language.ts @@ -0,0 +1,14 @@ +import { LanguageCode } from 'iso-639-1' +import strings from '../const/strings.json'; + +export type Locale = { + header: string + header_hub: string + online: string + members: string + button: string +} + +export function getLocaleStrings(lang: LanguageCode) { + return (strings as Record)[lang] || strings.en; +} \ No newline at end of file diff --git a/src/types/themes.ts b/src/types/themes.ts index 33d714d..a7e86d1 100644 --- a/src/types/themes.ts +++ b/src/types/themes.ts @@ -14,3 +14,20 @@ export type Theme = { export type Themes = { [key in ThemeVariation]: Theme; }; + +export type LegacyThemeColors = { + background: string, + header: string, + serverIcon: string, + acronymText: string, + joinButtonBackground: string, + joinButtonText: string, + serverName: string, + online: string, + members: string, + presenceText: string, + badges: { + VERIFIED: { flowerStar: string, icon: string }, + PARTNERED: { flowerStar: string, icon: string }, + }, +}; \ No newline at end of file diff --git a/src/util/base64ToArrayBuffer.ts b/src/util/base64ToArrayBuffer.ts new file mode 100644 index 0000000..e5b7e98 --- /dev/null +++ b/src/util/base64ToArrayBuffer.ts @@ -0,0 +1,9 @@ +export default function base64ToArrayBuffer(base64: string): ArrayBuffer { + const binaryString = atob(base64) + const len = binaryString.length + const bytes = new Uint8Array(len) + for (let i = 0; i < len; i++) { + bytes[i] = binaryString.charCodeAt(i) + } + return bytes.buffer +} \ No newline at end of file diff --git a/test/env.d.ts b/test/env.d.ts deleted file mode 100644 index d145fc7..0000000 --- a/test/env.d.ts +++ /dev/null @@ -1,3 +0,0 @@ -declare module 'cloudflare:test' { - interface ProvidedEnv extends Env {} -} diff --git a/test/index.spec.ts b/test/index.spec.ts deleted file mode 100644 index 5197296..0000000 --- a/test/index.spec.ts +++ /dev/null @@ -1,24 +0,0 @@ -import { env, createExecutionContext, waitOnExecutionContext, SELF } from 'cloudflare:test'; -import { describe, it, expect } from 'vitest'; -import worker from '../src/index'; - -// For now, you'll need to do something like this to get a correctly-typed -// `Request` to pass to `worker.fetch()`. -const IncomingRequest = Request; - -describe('Hello World worker', () => { - it('responds with Hello World! (unit style)', async () => { - const request = new IncomingRequest('http://example.com'); - // Create an empty context to pass to `worker.fetch()`. - const ctx = createExecutionContext(); - const response = await worker.fetch(request, env, ctx); - // Wait for all `Promise`s passed to `ctx.waitUntil()` to settle before running test assertions - await waitOnExecutionContext(ctx); - expect(await response.text()).toMatchInlineSnapshot(`"Hello World!"`); - }); - - it('responds with Hello World! (integration style)', async () => { - const response = await SELF.fetch('https://example.com'); - expect(await response.text()).toMatchInlineSnapshot(`"Hello World!"`); - }); -}); diff --git a/test/tsconfig.json b/test/tsconfig.json deleted file mode 100644 index 978ecd8..0000000 --- a/test/tsconfig.json +++ /dev/null @@ -1,8 +0,0 @@ -{ - "extends": "../tsconfig.json", - "compilerOptions": { - "types": ["@cloudflare/vitest-pool-workers"] - }, - "include": ["./**/*.ts", "../worker-configuration.d.ts"], - "exclude": [] -} diff --git a/tsconfig.json b/tsconfig.json index a5d0b31..2b47780 100644 --- a/tsconfig.json +++ b/tsconfig.json @@ -41,5 +41,4 @@ ] }, "exclude": ["test"], - "include": ["worker-configuration.d.ts", "src/**/*.ts", "src/components/InviteTemplate.tsx"] }