├── bun.lockb
├── .eslintrc.json
├── src
    ├── state.ts
    ├── pglite-worker.ts
    ├── app
    │   ├── api
    │   │   └── get-footer-ads
    │   │   │   └── route.ts
    │   ├── global.css
    │   ├── providers.tsx
    │   ├── layout.tsx
    │   └── page.tsx
    ├── components
    │   ├── posthog-pageview.tsx
    │   ├── footer.tsx
    │   ├── generate-delete-script-button.tsx
    │   └── dropzone-tweet-js.tsx
    ├── theme.ts
    ├── database
    │   ├── schema.ts
    │   └── db.ts
    └── screens
    │   ├── initial-page.tsx
    │   └── search-page.tsx
├── panda.config.ts
├── postcss.config.cjs
├── .gitignore
├── tsconfig.json
├── next.config.mjs
├── README.md
├── package.json
└── LICENSE


/bun.lockb:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/bgwastu/deletex/HEAD/bun.lockb


--------------------------------------------------------------------------------
/.eslintrc.json:
--------------------------------------------------------------------------------
1 | {
2 |   "extends": ["next/core-web-vitals", "next/typescript"],
3 |   "rules": {
4 |     "@typescript-eslint/no-explicit-any": "off"
5 |   }
6 | }
7 | 


--------------------------------------------------------------------------------
/src/state.ts:
--------------------------------------------------------------------------------
1 | import { atom } from "jotai";
2 | 
3 | export type AppState = "loading" | "initial" | "ready";
4 | 
5 | export const appStateAtom = atom<AppState>("loading");
6 | 


--------------------------------------------------------------------------------
/src/pglite-worker.ts:
--------------------------------------------------------------------------------
1 | import { PGlite } from "@electric-sql/pglite";
2 | import { worker } from "@electric-sql/pglite/worker";
3 | 
4 | worker({
5 |   async init() {
6 |     return new PGlite("idb://twt-data");
7 |   },
8 | });
9 | 


--------------------------------------------------------------------------------
/src/app/api/get-footer-ads/route.ts:
--------------------------------------------------------------------------------
1 | import { get } from "@vercel/edge-config";
2 | import { NextResponse } from "next/server";
3 | 
4 | export async function GET() {
5 |   const res = await get("footer_ads");
6 | 
7 |   return NextResponse.json(res);
8 | }
9 | 


--------------------------------------------------------------------------------
/panda.config.ts:
--------------------------------------------------------------------------------
 1 | import { defineConfig } from "@pandacss/dev";
 2 | 
 3 | export default defineConfig({
 4 |   preflight: true,
 5 |   include: ["./src/**/*.{js,jsx,ts,tsx}"],
 6 |   exclude: [],
 7 |   theme: {
 8 |     extend: {},
 9 |   },
10 |   outdir: "src/styled-system",
11 |   lightningcss: true,
12 | });
13 | 


--------------------------------------------------------------------------------
/src/app/global.css:
--------------------------------------------------------------------------------
 1 | @import url("@mantine/core/styles.css");
 2 | @import url("@mantine/dropzone/styles.css");
 3 | @import url("@mantine/notifications/styles.css");
 4 | @import url("@mantine/dates/styles.css");
 5 | @import url("@mantine/code-highlight/styles.css");
 6 | 
 7 | @layer reset, base, tokens, recipes, utilities;
 8 | 
 9 | body {
10 |   background-color: var(--mantine-color-brand-0);
11 | }
12 | 


--------------------------------------------------------------------------------
/postcss.config.cjs:
--------------------------------------------------------------------------------
 1 | module.exports = {
 2 |   plugins: {
 3 |     "postcss-preset-mantine": {},
 4 |     "postcss-simple-vars": {
 5 |       variables: {
 6 |         "mantine-breakpoint-xs": "36em",
 7 |         "mantine-breakpoint-sm": "48em",
 8 |         "mantine-breakpoint-md": "62em",
 9 |         "mantine-breakpoint-lg": "75em",
10 |         "mantine-breakpoint-xl": "88em",
11 |       },
12 |     },
13 |     "@pandacss/dev/postcss": {},
14 |   },
15 | };
16 | 


--------------------------------------------------------------------------------
/src/app/providers.tsx:
--------------------------------------------------------------------------------
 1 | "use client";
 2 | import posthog from "posthog-js";
 3 | import { PostHogProvider } from "posthog-js/react";
 4 | import { useEffect } from "react";
 5 | 
 6 | export function PHProvider({ children }: { children: React.ReactNode }) {
 7 |   useEffect(() => {
 8 |     posthog.init(process.env.NEXT_PUBLIC_POSTHOG_KEY!, {
 9 |       api_host: "/ingest",
10 |       ui_host: "https://us.posthog.com",
11 |       person_profiles: "identified_only",
12 |       capture_pageview: false, // Disable automatic pageview capture, as we capture manually
13 |     });
14 |   }, []);
15 | 
16 |   return <PostHogProvider client={posthog}>{children}</PostHogProvider>;
17 | }
18 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
 1 | # See https://help.github.com/articles/ignoring-files/ for more about ignoring files.
 2 | 
 3 | # dependencies
 4 | /node_modules
 5 | /.pnp
 6 | .pnp.js
 7 | .yarn/install-state.gz
 8 | 
 9 | # testing
10 | /coverage
11 | 
12 | # next.js
13 | /.next/
14 | /out/
15 | 
16 | # production
17 | /build
18 | 
19 | # misc
20 | .DS_Store
21 | *.pem
22 | 
23 | # debug
24 | npm-debug.log*
25 | yarn-debug.log*
26 | yarn-error.log*
27 | 
28 | # local env files
29 | .env*.local
30 | 
31 | # vercel
32 | .vercel
33 | 
34 | # typescript
35 | *.tsbuildinfo
36 | next-env.d.ts
37 | 
38 | # generated schema
39 | generated-schema/
40 | 
41 | ## Panda
42 | src/styled-system
43 | src/styled-system-studio


--------------------------------------------------------------------------------
/tsconfig.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "compilerOptions": {
 3 |     "lib": ["dom", "dom.iterable", "esnext"],
 4 |     "allowJs": true,
 5 |     "skipLibCheck": true,
 6 |     "strict": true,
 7 |     "noEmit": true,
 8 |     "esModuleInterop": true,
 9 |     "module": "esnext",
10 |     "moduleResolution": "bundler",
11 |     "resolveJsonModule": true,
12 |     "isolatedModules": true,
13 |     "jsx": "preserve",
14 |     "incremental": true,
15 |     "plugins": [
16 |       {
17 |         "name": "next"
18 |       }
19 |     ],
20 |     "paths": {
21 |       "@/*": ["./src/*"]
22 |     }
23 |   },
24 |   "include": ["next-env.d.ts", "**/*.ts", "**/*.tsx", ".next/types/**/*.ts"],
25 |   "exclude": ["node_modules"]
26 | }
27 | 


--------------------------------------------------------------------------------
/src/components/posthog-pageview.tsx:
--------------------------------------------------------------------------------
 1 | "use client";
 2 | 
 3 | import { usePathname, useSearchParams } from "next/navigation";
 4 | import { useEffect } from "react";
 5 | import { usePostHog } from "posthog-js/react";
 6 | 
 7 | export default function PostHogPageView(): null {
 8 |   const pathname = usePathname();
 9 |   const searchParams = useSearchParams();
10 |   const posthog = usePostHog();
11 |   useEffect(() => {
12 |     // Track pageviews
13 |     if (pathname && posthog) {
14 |       let url = window.origin + pathname;
15 |       if (searchParams.toString()) {
16 |         url = url + `?${searchParams.toString()}`;
17 |       }
18 |       posthog.capture("$pageview", {
19 |         $current_url: url,
20 |       });
21 |     }
22 |   }, [pathname, searchParams, posthog]);
23 | 
24 |   return null;
25 | }
26 | 


--------------------------------------------------------------------------------
/next.config.mjs:
--------------------------------------------------------------------------------
 1 | /** @type {import('next').NextConfig} */
 2 | const nextConfig = {
 3 |   swcMinify: false,
 4 |   experimental: {
 5 |     optimizePackageImports: ["@mantine/core", "@mantine/hooks"],
 6 |   },
 7 |   transpilePackages: ["@electric-sql/pglite-repl", "@electric-sql/pglite"],
 8 |   async rewrites() {
 9 |     return [
10 |       {
11 |         source: "/ingest/static/:path*",
12 |         destination: "https://us-assets.i.posthog.com/static/:path*",
13 |       },
14 |       {
15 |         source: "/ingest/:path*",
16 |         destination: "https://us.i.posthog.com/:path*",
17 |       },
18 |       {
19 |         source: "/ingest/decide",
20 |         destination: "https://us.i.posthog.com/decide",
21 |       },
22 |     ];
23 |   },
24 |   // This is required to support PostHog trailing slash API requests
25 |   skipTrailingSlashRedirect: true,
26 | };
27 | 
28 | export default nextConfig;
29 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # DeleteX
 2 | 
 3 | A web application that allows you to delete content on X (formerly known as Twiter) without having to log in or giving any third-party app access to your account.
 4 | 
 5 | See it in action at [deletex.wastu.net](https://deletex.wastu.net).
 6 | 
 7 | ## Features
 8 | 
 9 | * Delete all type of content on X (post, repost, and comments)
10 | * Powerful filtering options (date range, content type, min/max likes, min/max reposts, etc.)
11 | * Full-text search
12 | 
13 | ## How it works
14 | 
15 | DeleteX uses your X archive data to generate a userscript that you can run in your browser to delete your tweets. The script will run in your browser and will only delete the tweets you selected.
16 | 
17 | ## Privacy
18 | 
19 | DeleteX uses [PGLite](https://pglite.dev) as local storage to store your X archive data and the generated userscript. This means that your data is processed locally and never leaves your device.


--------------------------------------------------------------------------------
/src/theme.ts:
--------------------------------------------------------------------------------
 1 | import { createTheme, rem } from "@mantine/core";
 2 | 
 3 | export const theme = createTheme({
 4 |   fontFamily: "var(--font-text)",
 5 |   headings: {
 6 |     fontFamily: "var(--font-header)",
 7 |   },
 8 |   defaultRadius: 3,
 9 |   white: "#fff",
10 |   black: "#334155",
11 |   primaryColor: "brand",
12 |   colors: {
13 |     brand: [
14 |       "#f4f4f5",
15 |       "#e6e6e6",
16 |       "#cacaca",
17 |       "#aeaeae",
18 |       "#959597",
19 |       "#868689",
20 |       "#7e7e83",
21 |       "#6c6c71",
22 |       "#5f5f67",
23 |       "#52525c",
24 |     ],
25 |   },
26 |   primaryShade: 9,
27 |   fontSizes: {
28 |     xs: rem(12),
29 |     sm: rem(16),
30 |     md: rem(18),
31 |     lg: rem(20),
32 |     xl: rem(22),
33 |   },
34 |   components: {
35 |     Text: {
36 |       defaultProps: {
37 |         color: "brand.8",
38 |       },
39 |     },
40 |     Anchor: {
41 |       defaultProps: {
42 |         underline: "always",
43 |         fw: 600,
44 |       },
45 |     },
46 |     SegmentedControl: {
47 |       defaultProps: {
48 |         bg: "brand.1",
49 |       },
50 |     },
51 |     Button: {
52 |       defaultProps: {
53 |         style: {
54 |           textDecoration: "none",
55 |         },
56 |       },
57 |     },
58 |   },
59 | });
60 | 


--------------------------------------------------------------------------------
/src/app/layout.tsx:
--------------------------------------------------------------------------------
 1 | import { theme } from "@/theme";
 2 | import { ColorSchemeScript, MantineProvider } from "@mantine/core";
 3 | import { Notifications } from "@mantine/notifications";
 4 | import type { Metadata } from "next";
 5 | import { Figtree, Lora } from "next/font/google";
 6 | import "./global.css";
 7 | import { PHProvider } from "./providers";
 8 | 
 9 | const headerFont = Lora({
10 |   subsets: ["latin"],
11 |   weight: ["700"],
12 |   variable: "--font-header",
13 | });
14 | 
15 | const textFont = Figtree({
16 |   subsets: ["latin"],
17 |   weight: ["500", "600", "700"],
18 |   variable: "--font-text",
19 | });
20 | 
21 | export const metadata: Metadata = {
22 |   title: "DeleteX",
23 |   description: "Selectively delete your content on X (formerly Twitter).",
24 | };
25 | 
26 | export default function RootLayout({
27 |   children,
28 | }: Readonly<{
29 |   children: React.ReactNode;
30 | }>) {
31 |   return (
32 |     <html lang="en" className={`${headerFont.variable} ${textFont.variable}`}>
33 |       <head>
34 |         <ColorSchemeScript />
35 |       </head>
36 |       <body>
37 |         <PHProvider>
38 |           <MantineProvider theme={theme}>
39 |             <Notifications />
40 |             {children}
41 |           </MantineProvider>
42 |         </PHProvider>
43 |       </body>
44 |     </html>
45 |   );
46 | }
47 | 


--------------------------------------------------------------------------------
/src/app/page.tsx:
--------------------------------------------------------------------------------
 1 | "use client";
 2 | 
 3 | import { db, migrate } from "@/database/db";
 4 | import InitialPage from "@/screens/initial-page";
 5 | import SearchPage from "@/screens/search-page";
 6 | import { appStateAtom } from "@/state";
 7 | import { Loader, Stack, Text } from "@mantine/core";
 8 | import { sql } from "drizzle-orm";
 9 | import { useAtom } from "jotai";
10 | import { useEffect } from "react";
11 | 
12 | export default function Home() {
13 |   const [appState, setAppState] = useAtom(appStateAtom);
14 | 
15 |   useEffect(
16 |     function initial() {
17 |       (async () => {
18 |         await migrate();
19 |         const res = await db?.execute(sql`SELECT COUNT(*) FROM tweets;`);
20 |         const count = res?.rows[0]?.count;
21 | 
22 |         if (count === 0) {
23 |           setAppState("initial");
24 |         } else {
25 |           setAppState("ready");
26 |         }
27 |       })();
28 |     },
29 |     [setAppState]
30 |   );
31 | 
32 |   if (appState === "loading") {
33 |     return (
34 |       <Stack mih="99vh" align="center" justify="center">
35 |         <Loader />
36 |         <Text>Initializing, please wait...</Text>
37 |       </Stack>
38 |     );
39 |   } else if (appState === "ready") {
40 |     return <SearchPage />;
41 |   } else if (appState === "initial") {
42 |     return <InitialPage />;
43 |   }
44 | 
45 |   return <></>;
46 | }
47 | 


--------------------------------------------------------------------------------
/src/components/footer.tsx:
--------------------------------------------------------------------------------
 1 | "use client";
 2 | 
 3 | import { clear } from "@/database/db";
 4 | import { appStateAtom } from "@/state";
 5 | import { Anchor, Button, Flex } from "@mantine/core";
 6 | import { useFetch } from "@mantine/hooks";
 7 | import { useSetAtom } from "jotai";
 8 | import { useCallback, useState } from "react";
 9 | 
10 | interface FooterAds {
11 |   text: string;
12 |   url: string;
13 | }
14 | 
15 | export default function Footer() {
16 |   const [isDeleting, setIsDeleting] = useState(false);
17 |   const { data, loading } = useFetch<FooterAds>("/api/get-footer-ads");
18 |   const setAppState = useSetAtom(appStateAtom);
19 | 
20 |   const resetData = useCallback(async () => {
21 |     const confirmation = confirm("Are you sure you want to reset all data?");
22 |     if (!confirmation) return;
23 | 
24 |     setIsDeleting(true);
25 |     await clear();
26 |     setAppState("initial");
27 |     setIsDeleting(false);
28 |   }, [setAppState]);
29 | 
30 |   return (
31 |     <Flex justify="space-between" component="footer" mt="lg" align="center">
32 |       <Button
33 |         variant="outline"
34 |         onClick={resetData}
35 |         color="red.8"
36 |         loading={isDeleting}
37 |       >
38 |         Reset all the data
39 |       </Button>
40 |       <Anchor href={data?.url} c="dimmed" fw="normal">
41 |         {loading ? "Loading..." : data?.text}
42 |       </Anchor>
43 |     </Flex>
44 |   );
45 | }
46 | 


--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "deletex",
 3 |   "version": "0.1.0",
 4 |   "private": true,
 5 |   "scripts": {
 6 |     "prepare": "panda codegen",
 7 |     "dev": "next dev",
 8 |     "build": "next build",
 9 |     "start": "next start",
10 |     "lint": "next lint",
11 |     "generate-schema": "rm -rf generated-schema/ && bun drizzle-kit generate --dialect postgresql --driver pglite --name init --schema src/database/schema.ts --out generated-schema"
12 |   },
13 |   "dependencies": {
14 |     "@electric-sql/pglite": "^0.2.6",
15 |     "@electric-sql/pglite-repl": "^0.2.6",
16 |     "@mantine/code-highlight": "^7.12.2",
17 |     "@mantine/core": "^7.12.2",
18 |     "@mantine/dates": "^7.12.2",
19 |     "@mantine/dropzone": "^7.12.2",
20 |     "@mantine/form": "^7.12.2",
21 |     "@mantine/hooks": "^7.12.2",
22 |     "@mantine/notifications": "^7.12.2",
23 |     "@tabler/icons-react": "^3.17.0",
24 |     "@vercel/edge-config": "^1.3.0",
25 |     "dayjs": "^1.11.13",
26 |     "drizzle-orm": "^0.33.0",
27 |     "jotai": "^2.9.3",
28 |     "next": "14.2.35",
29 |     "posthog-js": "^1.164.2",
30 |     "react": "^19",
31 |     "react-dom": "^19",
32 |     "tough-cookie": "^4.1.4"
33 |   },
34 |   "devDependencies": {
35 |     "@pandacss/dev": "^0.46.0",
36 |     "@types/node": "^20",
37 |     "@types/react": "^18",
38 |     "@types/react-dom": "^18",
39 |     "drizzle-kit": "^0.24.2",
40 |     "eslint": "^8",
41 |     "eslint-config-next": "14.2.8",
42 |     "postcss": "^8.4.45",
43 |     "postcss-preset-mantine": "^1.17.0",
44 |     "postcss-simple-vars": "^7.0.1",
45 |     "typescript": "^5"
46 |   }
47 | }
48 | 


--------------------------------------------------------------------------------
/src/database/schema.ts:
--------------------------------------------------------------------------------
 1 | import { InferSelectModel, relations, sql } from "drizzle-orm";
 2 | import {
 3 |   index,
 4 |   integer,
 5 |   pgEnum,
 6 |   pgTable,
 7 |   timestamp,
 8 |   varchar,
 9 | } from "drizzle-orm/pg-core";
10 | 
11 | export const typeEnum = pgEnum("type", ["tweet", "retweet", "reply"]);
12 | export type TweetType = "tweet" | "retweet" | "reply";
13 | 
14 | export const tweets = pgTable(
15 |   "tweets",
16 |   {
17 |     id: varchar("id").primaryKey(),
18 |     text: varchar("text"),
19 |     retweet: integer("retweet"),
20 |     likes: integer("likes"),
21 |     type: typeEnum("type"),
22 |     createdAt: timestamp("created_at"),
23 |   },
24 |   (table) => ({
25 |     textSearchIndex: index("text_search_index").using(
26 |       "gin",
27 |       sql`to_tsvector('english', ${table.text})`
28 |     ),
29 |     typeIndex: index("type_index").on(table.type),
30 |   })
31 | );
32 | 
33 | export const tweetRelations = relations(tweets, ({ many }) => ({
34 |   media: many(media),
35 | }));
36 | 
37 | export type Tweet = InferSelectModel<typeof tweets>;
38 | export type TweetMedia = Tweet & { media: Media[] };
39 | 
40 | export const media = pgTable(
41 |   "media",
42 |   {
43 |     id: varchar("id").primaryKey(),
44 |     tweetId: varchar("tweet_id").references(() => tweets.id, {
45 |       onDelete: "cascade",
46 |       onUpdate: "cascade",
47 |     }),
48 |     previewUrl: varchar("url"),
49 |     type: varchar("type"),
50 |   },
51 |   (table) => ({
52 |     tweetIdIndex: index("tweet_id_index").on(table.tweetId),
53 |   })
54 | );
55 | 
56 | export const mediaRelations = relations(media, ({ one }) => ({
57 |   tweet: one(tweets, {
58 |     fields: [media.tweetId],
59 |     references: [tweets.id],
60 |   }),
61 | }));
62 | 
63 | export type Media = InferSelectModel<typeof media>;
64 | 


--------------------------------------------------------------------------------
/src/database/db.ts:
--------------------------------------------------------------------------------
 1 | "use client";
 2 | 
 3 | /* eslint-disable no-var */
 4 | /* eslint-disable prefer-const */
 5 | import { PGliteWorker } from "@electric-sql/pglite/worker";
 6 | import { drizzle, PgliteDatabase } from "drizzle-orm/pglite";
 7 | import * as schema from "./schema";
 8 | 
 9 | let db: PgliteDatabase<typeof schema> | undefined;
10 | let client: PGliteWorker | undefined;
11 | 
12 | if (typeof window !== "undefined") {
13 |   if (!client) {
14 |     client = new PGliteWorker(
15 |       new Worker(new URL("../pglite-worker.ts", import.meta.url), {
16 |         type: "module",
17 |       })
18 |     );
19 |   }
20 | 
21 |   if (!db) {
22 |     db = drizzle(client as any, { schema });
23 |   }
24 | }
25 | 
26 | export { db, client };
27 | 
28 | /**
29 |  * Executes the database migration.
30 |  *
31 |  * The query is manually generated by the drizzle-kit since the app is run in a browser.
32 |  */
33 | export async function migrate() {
34 |   // generated by drizzle-kit
35 |   const query = `DO $$ BEGIN
36 |  CREATE TYPE "public"."type" AS ENUM('tweet', 'retweet', 'reply');
37 | EXCEPTION
38 |  WHEN duplicate_object THEN null;
39 | END $$;
40 | --> statement-breakpoint
41 | CREATE TABLE IF NOT EXISTS "media" (
42 | 	"id" varchar PRIMARY KEY NOT NULL,
43 | 	"tweet_id" varchar,
44 | 	"url" varchar,
45 | 	"type" varchar
46 | );
47 | --> statement-breakpoint
48 | CREATE TABLE IF NOT EXISTS "tweets" (
49 | 	"id" varchar PRIMARY KEY NOT NULL,
50 | 	"text" varchar,
51 | 	"retweet" integer,
52 | 	"likes" integer,
53 | 	"type" "type",
54 | 	"created_at" timestamp
55 | );
56 | --> statement-breakpoint
57 | DO $$ BEGIN
58 |  ALTER TABLE "media" ADD CONSTRAINT "media_tweet_id_tweets_id_fk" FOREIGN KEY ("tweet_id") REFERENCES "public"."tweets"("id") ON DELETE cascade ON UPDATE cascade;
59 | EXCEPTION
60 |  WHEN duplicate_object THEN null;
61 | END $$;
62 | --> statement-breakpoint
63 | CREATE INDEX IF NOT EXISTS "tweet_id_index" ON "media" USING btree ("tweet_id");--> statement-breakpoint
64 | CREATE INDEX IF NOT EXISTS "text_search_index" ON "tweets" USING gin (to_tsvector('english', "text"));--> statement-breakpoint
65 | CREATE INDEX IF NOT EXISTS "type_index" ON "tweets" USING btree ("type");`;
66 | 
67 |   await client?.exec(query);
68 | }
69 | 
70 | /**
71 |  * Delete all tables and remigrate the database.
72 |  */
73 | export async function clear() {
74 |   const query = `DO $$ DECLARE
75 |     r RECORD;
76 |   BEGIN
77 |     FOR r IN (SELECT tablename FROM pg_tables WHERE schemaname = current_schema()) LOOP
78 |       EXECUTE 'DROP TABLE IF EXISTS ' || r.tablename || ' CASCADE';
79 |     END LOOP;
80 |   END $$;
81 |   `;
82 |   await client?.exec(query);
83 |   await migrate();
84 | }
85 | 


--------------------------------------------------------------------------------
/src/screens/initial-page.tsx:
--------------------------------------------------------------------------------
  1 | "use client";
  2 | 
  3 | import DropzoneTweetJs from "@/components/dropzone-tweet-js";
  4 | import { db } from "@/database/db";
  5 | import { media, TweetMedia, tweets } from "@/database/schema";
  6 | import { appStateAtom } from "@/state";
  7 | import {
  8 |   Button,
  9 |   Container,
 10 |   Divider,
 11 |   List,
 12 |   rem,
 13 |   Stack,
 14 |   Text,
 15 |   ThemeIcon,
 16 |   Title,
 17 | } from "@mantine/core";
 18 | import { notifications } from "@mantine/notifications";
 19 | import { IconCheck } from "@tabler/icons-react";
 20 | import { useSetAtom } from "jotai";
 21 | import { useState } from "react";
 22 | 
 23 | export default function InitialPage() {
 24 |   const [listTweet, setListTweet] = useState<TweetMedia[] | null>(null);
 25 |   const [loading, setLoading] = useState(false);
 26 |   const setAppState = useSetAtom(appStateAtom);
 27 | 
 28 |   async function saveTweetsToDatabase() {
 29 |     if (listTweet === null) return;
 30 |     setLoading(true);
 31 | 
 32 |     try {
 33 |       // Chunk tweets for insertion
 34 |       const MAX_INSERT_BATCH_SIZE = 1000;
 35 |       for (let i = 0; i < listTweet.length; i += MAX_INSERT_BATCH_SIZE) {
 36 |         await db
 37 |           ?.insert(tweets)
 38 |           .values(listTweet.slice(i, i + MAX_INSERT_BATCH_SIZE))
 39 |           .execute();
 40 |       }
 41 | 
 42 |       // insert media
 43 |       const mediaList = listTweet
 44 |         .map((tweet) => tweet.media)
 45 |         .flat()
 46 |         // filter duplicate media
 47 |         .filter(
 48 |           (media, index, self) =>
 49 |             index === self.findIndex((t) => t.id === media.id)
 50 |         );
 51 | 
 52 |       // Chunk media for insertion
 53 |       for (let i = 0; i < mediaList.length; i += MAX_INSERT_BATCH_SIZE) {
 54 |         await db
 55 |           ?.insert(media)
 56 |           .values(mediaList.slice(i, i + MAX_INSERT_BATCH_SIZE))
 57 |           .execute();
 58 |       }
 59 | 
 60 |       notifications.show({
 61 |         title: "Success",
 62 |         message: "Tweets imported successfully",
 63 |       });
 64 |       setAppState("ready");
 65 |     } catch (e: any) {
 66 |       console.error("Insertion error:", e);
 67 |       notifications.show({
 68 |         title: "Error",
 69 |         message: "Failed to save data to database. See console for details.",
 70 |         color: "red",
 71 |       });
 72 |     } finally {
 73 |       setLoading(false);
 74 |     }
 75 |   }
 76 | 
 77 |   return (
 78 |     <Container component="main" my="xl" size="sm">
 79 |       <Stack>
 80 |         <Stack gap="xs">
 81 |           <Title>DeleteX</Title>
 82 |           <Text>Selectively delete your content on X (formerly Twitter).</Text>
 83 |         </Stack>
 84 |         <Stack gap="xs">
 85 |           <Title order={2}>Features</Title>
 86 |           <List
 87 |             spacing="xs"
 88 |             size="sm"
 89 |             center
 90 |             icon={
 91 |               <ThemeIcon color="blue" size={24} radius="xl">
 92 |                 <IconCheck style={{ width: rem(16), height: rem(16) }} />
 93 |               </ThemeIcon>
 94 |             }
 95 |           >
 96 |             <List.Item>
 97 |               Deleting content using scripts (no auth/token required)
 98 |             </List.Item>
 99 |             <List.Item>
100 |               Powerful filtering options (date, media, etc.)
101 |             </List.Item>
102 |             <List.Item>Full-text search</List.Item>
103 |           </List>
104 |         </Stack>
105 |         <Divider my="sm" />
106 |         <DropzoneTweetJs setTweets={setListTweet} tweets={listTweet} />
107 |         {listTweet !== null && (
108 |           <Button size="md" onClick={saveTweetsToDatabase} loading={loading}>
109 |             Continue
110 |           </Button>
111 |         )}
112 |       </Stack>
113 |     </Container>
114 |   );
115 | }
116 | 


--------------------------------------------------------------------------------
/src/components/generate-delete-script-button.tsx:
--------------------------------------------------------------------------------
  1 | "use client";
  2 | 
  3 | import { CodeHighlight } from "@mantine/code-highlight";
  4 | import {
  5 |   Button,
  6 |   CopyButton,
  7 |   Modal,
  8 |   ScrollArea,
  9 |   Stack,
 10 |   Text,
 11 | } from "@mantine/core";
 12 | import { useDisclosure } from "@mantine/hooks";
 13 | import { IconCheck, IconCopy, IconFileTypeJs } from "@tabler/icons-react";
 14 | import { useState } from "react";
 15 | 
 16 | export default function GenerateDeleteScriptButton({
 17 |   tweetIds,
 18 |   disabled,
 19 | }: {
 20 |   tweetIds: string[];
 21 |   disabled?: boolean;
 22 | }) {
 23 |   const [opened, { open, close }] = useDisclosure(false);
 24 |   const [isLoading, setIsLoading] = useState(false);
 25 | 
 26 |   return (
 27 |     <div>
 28 |       <Modal opened={opened} onClose={close} title="Delete Script" size="lg">
 29 |         <Stack>
 30 |           <Stack gap="0">
 31 |             <Text size="sm" c="dimmed">
 32 |               STEP 1
 33 |             </Text>
 34 |             <Text>{`
 35 |             Open your browser's console (usually by pressing F12 or
 36 |             right-clicking on the page and selecting "Inspect" or "Inspect
 37 |             Element", then navigating to the "Console" tab).
 38 |           `}</Text>
 39 |           </Stack>
 40 |           <Stack gap="0">
 41 |             <Text size="sm" c="dimmed">
 42 |               STEP 2
 43 |             </Text>
 44 |             <Text>
 45 |               Copy and paste the script into the console and press Enter.
 46 |             </Text>
 47 |           </Stack>
 48 |           {tweetIds.length < 5000 ? (
 49 |             <ScrollArea h={300} type="always" scrollbars="y" offsetScrollbars>
 50 |               <CodeHighlight code={generate(tweetIds)} language="js" w={580} />
 51 |             </ScrollArea>
 52 |           ) : null}
 53 |           <CopyButton value={generate(tweetIds)}>
 54 |             {({ copied, copy }) => (
 55 |               <Button
 56 |                 color={copied ? "green.7" : "brand"}
 57 |                 onClick={copy}
 58 |                 leftSection={
 59 |                   copied ? <IconCheck size={14} /> : <IconCopy size={14} />
 60 |                 }
 61 |               >
 62 |                 {copied ? "Script Copied!" : "Copy Script to Clipboard"}
 63 |               </Button>
 64 |             )}
 65 |           </CopyButton>
 66 |         </Stack>
 67 |       </Modal>
 68 |       <Button
 69 |         onClick={() => {
 70 |           setIsLoading(true);
 71 |           open();
 72 |           setIsLoading(false);
 73 |         }}
 74 |         leftSection={<IconFileTypeJs size={18} />}
 75 |         color="brand"
 76 |         loading={isLoading}
 77 |         disabled={disabled}
 78 |       >
 79 |         Generate Delete Script
 80 |       </Button>
 81 |     </div>
 82 |   );
 83 | }
 84 | 
 85 | export function generate(tweetIds: string[]) {
 86 |   return `
 87 | var TweetDeleter = {
 88 |   deleteURL: "https://x.com/i/api/graphql/VaenaVgh5q5ih7kvyVjgtg/DeleteTweet",
 89 |   lastHeaders: {},
 90 |   tIds: [${tweetIds.map((id) => `"${id}"`).join(", ")}],
 91 |   dCount: 0,
 92 | 
 93 |   init: function() {
 94 |     this.initXHR();
 95 |     this.confirmDeletion();
 96 |   },
 97 | 
 98 |   initXHR: function() {
 99 |     var XHR_OpenOriginal = XMLHttpRequest.prototype.open;
100 |     XMLHttpRequest.prototype.open = function () {
101 |       if (arguments[1] && arguments[1].includes("DeleteTweet")) {
102 |         TweetDeleter.deleteURL = arguments[1];
103 |       }
104 |       XHR_OpenOriginal.apply(this, arguments);
105 |     };
106 | 
107 |     var XHR_SetRequestHeaderOriginal =
108 |       XMLHttpRequest.prototype.setRequestHeader;
109 |     XMLHttpRequest.prototype.setRequestHeader = function (a, b) {
110 |       TweetDeleter.lastHeaders[a] = b;
111 |       XHR_SetRequestHeaderOriginal.apply(this, arguments);
112 |     };
113 |   },
114 | 
115 |   confirmDeletion: async function() {
116 |     if (
117 |       confirm("Are you sure you want to delete " + this.tIds.length + " tweets?")
118 |     ) {
119 |       this.deleteTweets();
120 |     }
121 |   },
122 | 
123 |   deleteTweets: async function() {
124 |     while (!("authorization" in this.lastHeaders)) {
125 |       await this.sleep(1000);
126 |       console.log("Waiting for authorization...");
127 |     }
128 | 
129 |     console.log("Starting deletion...");
130 | 
131 |     while (this.tIds.length > 0) {
132 |       this.tId = this.tIds.pop();
133 |       try {
134 |         let response = await fetch(this.deleteURL, {
135 |           headers: {
136 |             accept: "*/*",
137 |             "accept-language": "en-US,en;q=0.5",
138 |             authorization: this.lastHeaders.authorization,
139 |             "content-type": "application/json",
140 |             "sec-fetch-dest": "empty",
141 |             "sec-fetch-mode": "cors",
142 |             "sec-fetch-site": "same-origin",
143 |             "x-client-transaction-id":
144 |               this.lastHeaders["X-Client-Transaction-Id"],
145 |             "x-client-uuid": this.lastHeaders["x-client-uuid"],
146 |             "x-csrf-token": this.lastHeaders["x-csrf-token"],
147 |             "x-twitter-active-user": "yes",
148 |             "x-twitter-auth-type": "OAuth2Session",
149 |             "x-twitter-client-language": "en",
150 |           },
151 |           referrer: "https://x.com/" + document.location.href.split("/")[3] + "/with_replies",
152 |           referrerPolicy: "strict-origin-when-cross-origin",
153 |           body: '{"variables":{"tweet_id":"' + this.tId + '","dark_request":false},"queryId":"' + this.deleteURL.split("/")[6] + '"}',
154 |           method: "POST",
155 |           mode: "cors",
156 |           credentials: "include",
157 |         });
158 | 
159 |         if (response.status == 200) {
160 |           this.dCount++;
161 |           console.log("Deleted tweet ID: " + this.tId + " - " + this.tIds.length + " tweets remaining...");
162 |         } else {
163 |           console.log("Failed to delete tweet ID: " + this.tId, response);
164 |         }
165 |       } catch (error) {
166 |         console.log("Error deleting tweet ID: " + this.tId, error);
167 |       }
168 |     }
169 | 
170 |     console.log("Tweet deletion complete!");
171 |     alert("Tweet deletion complete!");
172 |   },
173 | 
174 |   sleep: function(ms) {
175 |     return new Promise(function(resolve) {
176 |       setTimeout(resolve, ms);
177 |     });
178 |   },
179 | };
180 | 
181 | TweetDeleter.init();`;
182 | }
183 | 


--------------------------------------------------------------------------------
/src/components/dropzone-tweet-js.tsx:
--------------------------------------------------------------------------------
  1 | import { TweetMedia, TweetType } from "@/database/schema";
  2 | import {
  3 |   Anchor,
  4 |   BoxProps,
  5 |   Flex,
  6 |   Group,
  7 |   Pill,
  8 |   rem,
  9 |   Stack,
 10 |   Text,
 11 | } from "@mantine/core";
 12 | import { Dropzone } from "@mantine/dropzone";
 13 | import { notifications } from "@mantine/notifications";
 14 | import { IconFileTypeJs, IconUpload, IconX } from "@tabler/icons-react";
 15 | import { useState } from "react";
 16 | 
 17 | type Props = {
 18 |   tweets: TweetMedia[] | null;
 19 |   setTweets: (tweets: TweetMedia[] | null) => void;
 20 | } & BoxProps;
 21 | 
 22 | export default function DropzoneTweetJs({
 23 |   tweets,
 24 |   setTweets,
 25 |   ...props
 26 | }: Props) {
 27 |   const [loading, setLoading] = useState(false);
 28 |   const [file, setFile] = useState<File | null>(null);
 29 |   return (
 30 |     <Stack {...props}>
 31 |       {file === null ? (
 32 |         <Stack>
 33 |           <Dropzone
 34 |             disabled={loading || file !== null}
 35 |             onDrop={async (files) => {
 36 |               setLoading(true);
 37 |               try {
 38 |                 const tweets = await fileToTweets(files[0]);
 39 |                 setFile(files[0]);
 40 |                 setTweets(tweets);
 41 |               } catch (error) {
 42 |                 console.error("Error processing file:", error);
 43 |                 notifications.show({
 44 |                   title: "Error",
 45 |                   message:
 46 |                     "Failed to process the file. Please check the console for more details.",
 47 |                   color: "red",
 48 |                 });
 49 |               } finally {
 50 |                 setLoading(false);
 51 |               }
 52 |             }}
 53 |             onReject={(files) => {
 54 |               files[0].errors.map((e) => {
 55 |                 notifications.show({
 56 |                   title: `Error on file ${files[0].file.name}`,
 57 |                   message: e.message,
 58 |                   color: "red",
 59 |                 });
 60 |               });
 61 |             }}
 62 |             multiple={false}
 63 |           >
 64 |             <Group
 65 |               justify="center"
 66 |               gap="xl"
 67 |               mih={220}
 68 |               style={{ pointerEvents: "none" }}
 69 |             >
 70 |               <Dropzone.Accept>
 71 |                 <IconUpload
 72 |                   style={{
 73 |                     width: rem(52),
 74 |                     height: rem(52),
 75 |                     color: "var(--mantine-color-brand-6)",
 76 |                   }}
 77 |                   stroke={1.5}
 78 |                 />
 79 |               </Dropzone.Accept>
 80 |               <Dropzone.Reject>
 81 |                 <IconX
 82 |                   style={{
 83 |                     width: rem(52),
 84 |                     height: rem(52),
 85 |                     color: "var(--mantine-color-red-6)",
 86 |                   }}
 87 |                   stroke={1.5}
 88 |                 />
 89 |               </Dropzone.Reject>
 90 |               <Dropzone.Idle>
 91 |                 <IconFileTypeJs
 92 |                   style={{
 93 |                     width: rem(52),
 94 |                     height: rem(52),
 95 |                     color: "var(--mantine-color-brand-6)",
 96 |                   }}
 97 |                   stroke={1.5}
 98 |                 />
 99 |               </Dropzone.Idle>
100 |               <Stack gap="xs">
101 |                 <Text size="xl" inline>
102 |                   Upload your tweets.js file
103 |                 </Text>
104 |                 <Text size="sm" c="dimmed" inline>
105 |                   You can also drag and drop the file here
106 |                 </Text>
107 |               </Stack>
108 |             </Group>
109 |           </Dropzone>
110 |           <Text>
111 |             Before continuing, you need to import tweets.js file from your X
112 |             archive.{" "}
113 |             <Anchor
114 |               target="_blank"
115 |               href="https://help.x.com/en/managing-your-account/how-to-download-your-x-archive"
116 |             >
117 |               See how to download it
118 |             </Anchor>
119 |             .
120 |           </Text>
121 |         </Stack>
122 |       ) : (
123 |         <Stack>
124 |           <Flex>
125 |             <Pill
126 |               size="lg"
127 |               bg="brand.1"
128 |               withRemoveButton
129 |               removeButtonProps={{
130 |                 onClick: () => {
131 |                   setFile(null);
132 |                   setTweets(null);
133 |                 },
134 |               }}
135 |             >
136 |               {file?.name} ({tweets?.length} posts)
137 |             </Pill>
138 |           </Flex>
139 |           <Stack gap="xs">
140 |             <Text>
141 |               Posts:{" "}
142 |               <Text span fw={600}>
143 |                 {tweets?.filter((tweet) => tweet.type === "tweet").length}
144 |               </Text>
145 |             </Text>
146 |             <Text>
147 |               Retweets:{" "}
148 |               <Text span fw={600}>
149 |                 {tweets?.filter((tweet) => tweet.type === "retweet").length}{" "}
150 |               </Text>
151 |             </Text>
152 |             <Text>
153 |               Replies:{" "}
154 |               <Text span fw={600}>
155 |                 {tweets?.filter((tweet) => tweet.type === "reply").length}{" "}
156 |               </Text>
157 |             </Text>
158 |           </Stack>
159 |         </Stack>
160 |       )}
161 |     </Stack>
162 |   );
163 | }
164 | 
165 | async function fileToTweets(file: File): Promise<TweetMedia[]> {
166 |   const content = await file.text();
167 |   const jsonString = content.replace(/^window\.YTD\.tweets\.part0 = /, "");
168 |   if (!jsonString) throw new Error("Invalid tweets.js file");
169 | 
170 |   try {
171 |     const data = JSON.parse(jsonString);
172 | 
173 |     return data.map((data: any) => {
174 |       const tweet = data.tweet;
175 | 
176 |       let type: TweetType = "tweet";
177 | 
178 |       if (tweet.in_reply_to_status_id_str !== undefined) {
179 |         type = "reply";
180 |       } else if (tweet.full_text.startsWith("RT @")) {
181 |         type = "retweet";
182 |       }
183 | 
184 |       return {
185 |         id: tweet.id_str,
186 |         text: tweet.full_text,
187 |         retweet: Number(tweet.retweet_count),
188 |         likes: Number(tweet.favorite_count),
189 |         createdAt: new Date(tweet.created_at),
190 |         type,
191 |         media: [...(tweet.extended_entities?.media || [])].map(
192 |           (media: any) => ({
193 |             id: media.id_str,
194 |             tweetId: tweet.id_str,
195 |             previewUrl: media.media_url_https,
196 |             type: media.type,
197 |           })
198 |         ),
199 |       } as TweetMedia;
200 |     });
201 |   } catch (error) {
202 |     console.error(error);
203 |     throw new Error("Invalid tweets.js file");
204 |   }
205 | }
206 | 


--------------------------------------------------------------------------------
/src/screens/search-page.tsx:
--------------------------------------------------------------------------------
  1 | "use client";
  2 | 
  3 | import Footer from "@/components/footer";
  4 | import GenerateDeleteScriptButton from "@/components/generate-delete-script-button";
  5 | import { db } from "@/database/db";
  6 | import { media, TweetMedia, tweets } from "@/database/schema";
  7 | import { css } from "@/styled-system/css";
  8 | import {
  9 |   Anchor,
 10 |   Box,
 11 |   Button,
 12 |   Center,
 13 |   Checkbox,
 14 |   Container,
 15 |   Flex,
 16 |   Group,
 17 |   Image,
 18 |   Input,
 19 |   Loader,
 20 |   MultiSelect,
 21 |   NumberInput,
 22 |   Popover,
 23 |   SimpleGrid,
 24 |   Stack,
 25 |   Text,
 26 |   TextInput,
 27 |   ThemeIcon,
 28 | } from "@mantine/core";
 29 | import { DatePickerInput } from "@mantine/dates";
 30 | import { useForm } from "@mantine/form";
 31 | import { useDebouncedCallback, useDisclosure } from "@mantine/hooks";
 32 | import { notifications } from "@mantine/notifications";
 33 | import {
 34 |   IconArticle,
 35 |   IconFilter,
 36 |   IconFilterFilled,
 37 |   IconHeart,
 38 |   IconHeartFilled,
 39 |   IconMessage,
 40 |   IconPlayerPlayFilled,
 41 |   IconRepeat,
 42 | } from "@tabler/icons-react";
 43 | import { and, desc, eq, exists, gte, lt, lte, or, sql } from "drizzle-orm";
 44 | import { useCallback, useEffect, useMemo, useState } from "react";
 45 | 
 46 | const PAGE_SIZE = 20;
 47 | const TWEET_TYPES = [
 48 |   { value: "tweet", label: "Post" },
 49 |   { value: "retweet", label: "Repost" },
 50 |   { value: "reply", label: "Reply" },
 51 | ];
 52 | 
 53 | export default function SearchPage() {
 54 |   const [loadingState, setLoadingState] = useState<
 55 |     "initial" | "pagination" | "filter" | "reset" | "select_all" | null
 56 |   >("initial");
 57 |   const [listTweet, setListTweet] = useState<TweetMedia[]>([]);
 58 |   const [selectedTweetId, setSelectedTweetId] = useState<string[]>([]);
 59 |   const [query, setQuery] = useState("");
 60 |   const [filterOpened, { close: closeFilter, open: openFilter }] =
 61 |     useDisclosure(false);
 62 |   const [totalPossibleTweet, setTotalPossibleTweet] = useState(0);
 63 | 
 64 |   const form = useForm({
 65 |     initialValues: {
 66 |       tweetType: [] as ("retweet" | "tweet" | "reply")[],
 67 |       startDate: null as Date | null,
 68 |       endDate: null as Date | null,
 69 |       minLikes: null as number | null,
 70 |       maxLikes: null as number | null,
 71 |       minRetweet: null as number | null,
 72 |       maxRetweet: null as number | null,
 73 |       containsMedia: false,
 74 |     },
 75 |     validate: {
 76 |       startDate: (value, values) =>
 77 |         value && values.endDate && value > values.endDate
 78 |           ? "Start date must be before end date"
 79 |           : null,
 80 |       endDate: (value, values) =>
 81 |         value && values.startDate && value < values.startDate
 82 |           ? "End date must be after start date"
 83 |           : null,
 84 |     },
 85 |   });
 86 | 
 87 |   const isSelectAll = useMemo(
 88 |     () =>
 89 |       (listTweet.length > 0 &&
 90 |         loadingState === null &&
 91 |         listTweet.every((tweet) => selectedTweetId.includes(tweet.id))) ||
 92 |       selectedTweetId.length === totalPossibleTweet,
 93 |     [listTweet, loadingState, selectedTweetId, totalPossibleTweet]
 94 |   );
 95 | 
 96 |   const getWhereClause = useCallback(() => {
 97 |     const {
 98 |       startDate,
 99 |       endDate,
100 |       minLikes,
101 |       maxLikes,
102 |       minRetweet,
103 |       maxRetweet,
104 |       tweetType,
105 |       containsMedia,
106 |     } = form.values;
107 |     if (!db) return;
108 | 
109 |     const mediaSubquery = db
110 |       .select()
111 |       .from(media)
112 |       .where(eq(media.tweetId, tweets.id));
113 |     return and(
114 |       minLikes !== null && typeof minLikes !== "string"
115 |         ? gte(tweets.likes, minLikes)
116 |         : undefined,
117 |       maxLikes !== null && typeof maxLikes !== "string"
118 |         ? lte(tweets.likes, maxLikes)
119 |         : undefined,
120 |       minRetweet !== null && typeof minRetweet !== "string"
121 |         ? gte(tweets.retweet, minRetweet)
122 |         : undefined,
123 |       maxRetweet !== null && typeof maxRetweet !== "string"
124 |         ? lte(tweets.retweet, maxRetweet)
125 |         : undefined,
126 |       startDate ? gte(tweets.createdAt, startDate) : undefined,
127 |       endDate ? lte(tweets.createdAt, endDate) : undefined,
128 |       tweetType.length > 0
129 |         ? or(...tweetType.map((type) => eq(tweets.type, type)))
130 |         : undefined,
131 |       containsMedia ? exists(mediaSubquery) : undefined
132 |     );
133 |   }, [form.values]);
134 | 
135 |   const getListTweet = useCallback(
136 |     async (
137 |       cursor?: Date,
138 |       query?: string,
139 |       columns?: any,
140 |       pageSize: number = PAGE_SIZE,
141 |       withMedia: boolean = true,
142 |       countResult: boolean = true
143 |     ) => {
144 |       const whereClause = getWhereClause();
145 |       const searchClause = query
146 |         ? sql`to_tsvector('english', ${tweets.text}) @@ plainto_tsquery('english', ${query})`
147 |         : undefined;
148 |       const cursorClause = cursor ? lt(tweets.createdAt, cursor) : undefined;
149 | 
150 |       const w = withMedia
151 |         ? {
152 |             media: {
153 |               columns: {
154 |                 previewUrl: true,
155 |                 type: true,
156 |               },
157 |             },
158 |           }
159 |         : undefined;
160 | 
161 |       const tweetResults = await db?.query.tweets.findMany({
162 |         columns,
163 |         limit: pageSize,
164 |         where: and(cursorClause, whereClause, searchClause),
165 |         with: w,
166 |         orderBy: desc(tweets.createdAt),
167 |       });
168 | 
169 |       if (tweetResults && countResult) {
170 |         const countResults = await db
171 |           ?.select({ count: sql`count(*)`.mapWith(Number) })
172 |           .from(tweets)
173 |           .where(and(cursorClause, whereClause, searchClause));
174 | 
175 |         if (countResults?.[0].count)
176 |           setTotalPossibleTweet(countResults[0].count);
177 | 
178 |         if (countResults?.[0].count === listTweet.length) return [];
179 |       }
180 | 
181 |       return tweetResults as any[];
182 |     },
183 |     [getWhereClause, listTweet.length]
184 |   );
185 | 
186 |   const selectAll = useCallback(async () => {
187 |     setLoadingState("select_all");
188 |     let tweetIds: string[] = [];
189 |     let cursor;
190 |     while (true) {
191 |       const res = await getListTweet(
192 |         cursor,
193 |         query,
194 |         {
195 |           id: true,
196 |           createdAt: true,
197 |         },
198 |         2000,
199 |         false,
200 |         false
201 |       );
202 |       if (res.length === 0 || tweetIds.length >= totalPossibleTweet) break;
203 |       tweetIds = Array.from(
204 |         new Set(tweetIds.concat(res.map((tweet) => tweet.id)))
205 |       );
206 |       setSelectedTweetId(tweetIds);
207 |       cursor = res[res.length - 1].createdAt;
208 |     }
209 | 
210 |     if (tweetIds) {
211 |       setSelectedTweetId(tweetIds);
212 |     }
213 |     setLoadingState(null);
214 |   }, [getListTweet, query, totalPossibleTweet]);
215 | 
216 |   const clearAll = useCallback(() => {
217 |     setSelectedTweetId([]);
218 |   }, []);
219 | 
220 |   const loadMore = useCallback(async () => {
221 |     setLoadingState("pagination");
222 |     const lastTweet = listTweet[listTweet.length - 1];
223 |     const res = await getListTweet(lastTweet.createdAt ?? undefined);
224 |     if (res) {
225 |       setListTweet((prev) => [...prev, ...res]);
226 |     } else {
227 |       notifications.show({
228 |         title: "No more content",
229 |         message: "You have reached the end of the contents.",
230 |       });
231 |     }
232 |     setLoadingState(null);
233 |   }, [getListTweet, listTweet]);
234 | 
235 |   const applyFilter = useCallback(async () => {
236 |     setLoadingState("filter");
237 |     const res = await getListTweet();
238 |     if (res) setListTweet(res);
239 |     setLoadingState(null);
240 |     closeFilter();
241 |   }, [getListTweet, closeFilter]);
242 | 
243 |   const handleSearch = useDebouncedCallback(async (keyword: string) => {
244 |     if (keyword === "") {
245 |       const res = await getListTweet();
246 |       if (res) setListTweet(res);
247 |       return;
248 |     }
249 | 
250 |     setListTweet([]);
251 |     const res = await getListTweet(undefined, keyword);
252 |     if (res) setListTweet(res);
253 |     clearAll();
254 |   }, 500);
255 | 
256 |   const toggleTweetSelection = useCallback((tweetId: string) => {
257 |     setSelectedTweetId((prev) =>
258 |       prev.includes(tweetId)
259 |         ? prev.filter((id) => id !== tweetId)
260 |         : [...prev, tweetId]
261 |     );
262 |   }, []);
263 | 
264 |   const renderTweetTypeIcon = useCallback((type: string) => {
265 |     const iconProps = { style: { width: "70%", height: "70%" } };
266 |     switch (type) {
267 |       case "retweet":
268 |         return <IconRepeat {...iconProps} />;
269 |       case "reply":
270 |         return <IconMessage {...iconProps} />;
271 |       default:
272 |         return <IconArticle {...iconProps} />;
273 |     }
274 |   }, []);
275 | 
276 |   useEffect(() => {
277 |     getListTweet().then((res) => {
278 |       if (res) setListTweet(res);
279 |       setLoadingState(null);
280 |     });
281 |     // eslint-disable-next-line react-hooks/exhaustive-deps
282 |   }, []);
283 | 
284 |   if (loadingState === "initial") {
285 |     return (
286 |       <Stack mih="99vh" align="center" justify="center">
287 |         <Loader />
288 |         <Text>Load the data, please wait...</Text>
289 |       </Stack>
290 |     );
291 |   }
292 | 
293 |   return (
294 |     <Container my="xl">
295 |       <Stack>
296 |         <Stack>
297 |           <Flex gap="sm">
298 |             <TextInput
299 |               size="md"
300 |               placeholder="Search posts..."
301 |               value={query}
302 |               flex={1}
303 |               onChange={(e) => {
304 |                 setQuery(e.currentTarget.value);
305 |                 handleSearch(e.currentTarget.value);
306 |               }}
307 |             />
308 |             <Popover
309 |               width={350}
310 |               trapFocus
311 |               withArrow
312 |               shadow="md"
313 |               clickOutsideEvents={[]}
314 |               opened={filterOpened}
315 |             >
316 |               <Popover.Target>
317 |                 <Button
318 |                   size="md"
319 |                   leftSection={
320 |                     form.isDirty() ? (
321 |                       <IconFilterFilled size={18} />
322 |                     ) : (
323 |                       <IconFilter size={18} />
324 |                     )
325 |                   }
326 |                   variant={form.isDirty() ? "filled" : "outline"}
327 |                   onClick={filterOpened ? closeFilter : openFilter}
328 |                 >
329 |                   Filter
330 |                 </Button>
331 |               </Popover.Target>
332 |               <Popover.Dropdown>
333 |                 <form onSubmit={form.onSubmit(applyFilter)}>
334 |                   <Stack>
335 |                     <MultiSelect
336 |                       label="Content Type"
337 |                       data={TWEET_TYPES}
338 |                       clearable
339 |                       size="sm"
340 |                       {...form.getInputProps("tweetType")}
341 |                     />
342 |                     <Stack gap="xs">
343 |                       <Input.Wrapper label="Date Range">
344 |                         <Group gap="sm" grow>
345 |                           <DatePickerInput
346 |                             placeholder="From"
347 |                             valueFormat="DD/MM/YYYY"
348 |                             clearable
349 |                             {...form.getInputProps("startDate")}
350 |                           />
351 |                           <DatePickerInput
352 |                             placeholder="To"
353 |                             valueFormat="DD/MM/YYYY"
354 |                             maxDate={new Date()}
355 |                             clearable
356 |                             {...form.getInputProps("endDate")}
357 |                           />
358 |                         </Group>
359 |                       </Input.Wrapper>
360 |                     </Stack>
361 |                     <Input.Wrapper label="Likes Range">
362 |                       <Flex gap="sm" align="start">
363 |                         <NumberInput
364 |                           aria-label="Minimum likes"
365 |                           flex={1}
366 |                           min={0}
367 |                           step={1}
368 |                           placeholder="Minimum"
369 |                           leftSection={<IconHeart size={14} />}
370 |                           hideControls
371 |                           {...form.getInputProps("minLikes")}
372 |                         />
373 |                         <NumberInput
374 |                           aria-label="Maximum likes"
375 |                           placeholder="Maximum"
376 |                           flex={1}
377 |                           min={0}
378 |                           step={1}
379 |                           defaultValue={null}
380 |                           leftSection={<IconHeart size={14} />}
381 |                           hideControls
382 |                           {...form.getInputProps("maxLikes")}
383 |                         />
384 |                       </Flex>
385 |                     </Input.Wrapper>
386 |                     <Input.Wrapper label="Repost Range">
387 |                       <Flex gap="sm" align="start">
388 |                         <NumberInput
389 |                           aria-label="Minimum likes"
390 |                           flex={1}
391 |                           min={0}
392 |                           step={1}
393 |                           placeholder="Minimum"
394 |                           leftSection={<IconRepeat size={14} />}
395 |                           hideControls
396 |                           {...form.getInputProps("minRetweet")}
397 |                         />
398 |                         <NumberInput
399 |                           aria-label="Maximum reposts"
400 |                           placeholder="Maximum"
401 |                           flex={1}
402 |                           min={0}
403 |                           leftSection={<IconRepeat size={14} />}
404 |                           step={1}
405 |                           hideControls
406 |                           {...form.getInputProps("maxRetweet")}
407 |                         />
408 |                       </Flex>
409 |                     </Input.Wrapper>
410 |                     <Checkbox
411 |                       label="Contains media"
412 |                       {...form.getInputProps("containsMedia", {
413 |                         type: "checkbox",
414 |                       })}
415 |                     />
416 |                     <Button type="submit" loading={loadingState === "filter"}>
417 |                       Apply Filters
418 |                     </Button>
419 |                   </Stack>
420 |                 </form>
421 |               </Popover.Dropdown>
422 |             </Popover>
423 |           </Flex>
424 |           {selectedTweetId.length > 0 && (
425 |             <Group justify="space-between">
426 |               <Flex align="center" gap="sm">
427 |                 <Button
428 |                   onClick={isSelectAll ? clearAll : selectAll}
429 |                   color={isSelectAll ? "red" : "brand"}
430 |                   variant={isSelectAll ? "light" : "filled"}
431 |                   loading={loadingState === "select_all"}
432 |                 >
433 |                   {isSelectAll ? "Clear all selection" : "Select all"}
434 |                 </Button>
435 |                 <Text
436 |                   c="dimmed"
437 |                   size="sm"
438 |                 >{`${selectedTweetId.length} of ${totalPossibleTweet} selected`}</Text>
439 |               </Flex>
440 |               <GenerateDeleteScriptButton
441 |                 tweetIds={selectedTweetId}
442 |                 disabled={loadingState === "select_all"}
443 |               />
444 |             </Group>
445 |           )}
446 |         </Stack>
447 |         <Stack>
448 |           {listTweet.map((tweet) => (
449 |             <Checkbox.Card
450 |               py="md"
451 |               px="sm"
452 |               className={css({
453 |                 transition: "border-color 150ms ease",
454 |                 "&[data-checked]": {
455 |                   borderColor: "var(--mantine-primary-color-filled)!",
456 |                 },
457 |               })}
458 |               value={tweet.id}
459 |               key={tweet.id}
460 |               checked={selectedTweetId.includes(tweet.id)}
461 |               onClick={() => toggleTweetSelection(tweet.id)}
462 |               bg="white"
463 |             >
464 |               <Flex gap="sm">
465 |                 <Checkbox.Indicator mt={4} />
466 |                 <Stack w="100%" gap="xs">
467 |                   <Flex justify="space-between">
468 |                     <Flex gap={2} align="center">
469 |                       <ThemeIcon
470 |                         variant="white"
471 |                         size="md"
472 |                         c={
473 |                           tweet.type === "retweet"
474 |                             ? "green.6"
475 |                             : tweet.type === "reply"
476 |                               ? "blue.6"
477 |                               : "dimmed"
478 |                         }
479 |                       >
480 |                         {renderTweetTypeIcon(tweet.type ?? "tweet")}
481 |                       </ThemeIcon>
482 |                       <Text size="sm" c="dimmed">
483 |                         {TWEET_TYPES.find((t) => t.value === tweet.type)?.label}
484 |                       </Text>
485 |                     </Flex>
486 |                     <Anchor
487 |                       href={`https://x.com/i/web/status/${tweet.id}`}
488 |                       fz="sm"
489 |                       c="dimmed"
490 |                       target="_blank"
491 |                     >
492 |                       {tweet.createdAt?.toLocaleDateString()}{" "}
493 |                       {tweet.createdAt?.toLocaleString([], {
494 |                         hour: "2-digit",
495 |                         minute: "2-digit",
496 |                       })}
497 |                     </Anchor>
498 |                   </Flex>
499 |                   <Text>{tweet.text}</Text>
500 |                   {tweet.media && tweet.media.length > 0 && (
501 |                     <SimpleGrid
502 |                       spacing="sm"
503 |                       cols={{
504 |                         base: 1,
505 |                         sm: 2,
506 |                         md: 3,
507 |                       }}
508 |                     >
509 |                       {tweet.media.map((mediaItem, index) => (
510 |                         <Box
511 |                           key={index}
512 |                           className={css({
513 |                             position: "relative",
514 |                           })}
515 |                         >
516 |                           <Image
517 |                             src={mediaItem.previewUrl}
518 |                             alt={`media-${index}`}
519 |                           />
520 |                           {mediaItem.type !== "photo" && (
521 |                             <Anchor
522 |                               href={"https://x.com/i/web/status/" + tweet.id}
523 |                               target="_blank"
524 |                             >
525 |                               <Center
526 |                                 className={css({
527 |                                   position: "absolute",
528 |                                   top: "5",
529 |                                   left: "5",
530 |                                   right: "5",
531 |                                   bottom: "5",
532 |                                 })}
533 |                               >
534 |                                 <ThemeIcon
535 |                                   size="xl"
536 |                                   variant="default"
537 |                                   radius="xl"
538 |                                 >
539 |                                   <IconPlayerPlayFilled size={24} />
540 |                                 </ThemeIcon>
541 |                               </Center>
542 |                             </Anchor>
543 |                           )}
544 |                         </Box>
545 |                       ))}
546 |                     </SimpleGrid>
547 |                   )}
548 |                   <Group gap="xs">
549 |                     <Flex gap={2} align="center">
550 |                       <ThemeIcon variant="white" size="sm" c="dimmed">
551 |                         <IconHeartFilled
552 |                           style={{ width: "70%", height: "70%" }}
553 |                         />
554 |                       </ThemeIcon>
555 |                       <Text fz="sm" c="dimmed">
556 |                         {tweet.likes}
557 |                       </Text>
558 |                     </Flex>
559 |                     <Flex gap={2} align="center">
560 |                       <ThemeIcon variant="white" size="sm" c="dimmed">
561 |                         <IconRepeat style={{ width: "70%", height: "70%" }} />
562 |                       </ThemeIcon>
563 |                       <Text fz="sm" c="dimmed">
564 |                         {tweet.retweet}
565 |                       </Text>
566 |                     </Flex>
567 |                   </Group>
568 |                 </Stack>
569 |               </Flex>
570 |             </Checkbox.Card>
571 |           ))}
572 |         </Stack>
573 |         <Button
574 |           onClick={loadMore}
575 |           hidden={
576 |             totalPossibleTweet === listTweet.length || listTweet.length === 0
577 |           }
578 |           loading={loadingState === "pagination"}
579 |         >
580 |           Load more
581 |         </Button>
582 |       </Stack>
583 |       <Footer />
584 |     </Container>
585 |   );
586 | }
587 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
  1 |                     GNU GENERAL PUBLIC LICENSE
  2 |                        Version 3, 29 June 2007
  3 | 
  4 |  Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
  5 |  Everyone is permitted to copy and distribute verbatim copies
  6 |  of this license document, but changing it is not allowed.
  7 | 
  8 |                             Preamble
  9 | 
 10 |   The GNU General Public License is a free, copyleft license for
 11 | software and other kinds of works.
 12 | 
 13 |   The licenses for most software and other practical works are designed
 14 | to take away your freedom to share and change the works.  By contrast,
 15 | the GNU General Public License is intended to guarantee your freedom to
 16 | share and change all versions of a program--to make sure it remains free
 17 | software for all its users.  We, the Free Software Foundation, use the
 18 | GNU General Public License for most of our software; it applies also to
 19 | any other work released this way by its authors.  You can apply it to
 20 | your programs, too.
 21 | 
 22 |   When we speak of free software, we are referring to freedom, not
 23 | price.  Our General Public Licenses are designed to make sure that you
 24 | have the freedom to distribute copies of free software (and charge for
 25 | them if you wish), that you receive source code or can get it if you
 26 | want it, that you can change the software or use pieces of it in new
 27 | free programs, and that you know you can do these things.
 28 | 
 29 |   To protect your rights, we need to prevent others from denying you
 30 | these rights or asking you to surrender the rights.  Therefore, you have
 31 | certain responsibilities if you distribute copies of the software, or if
 32 | you modify it: responsibilities to respect the freedom of others.
 33 | 
 34 |   For example, if you distribute copies of such a program, whether
 35 | gratis or for a fee, you must pass on to the recipients the same
 36 | freedoms that you received.  You must make sure that they, too, receive
 37 | or can get the source code.  And you must show them these terms so they
 38 | know their rights.
 39 | 
 40 |   Developers that use the GNU GPL protect your rights with two steps:
 41 | (1) assert copyright on the software, and (2) offer you this License
 42 | giving you legal permission to copy, distribute and/or modify it.
 43 | 
 44 |   For the developers' and authors' protection, the GPL clearly explains
 45 | that there is no warranty for this free software.  For both users' and
 46 | authors' sake, the GPL requires that modified versions be marked as
 47 | changed, so that their problems will not be attributed erroneously to
 48 | authors of previous versions.
 49 | 
 50 |   Some devices are designed to deny users access to install or run
 51 | modified versions of the software inside them, although the manufacturer
 52 | can do so.  This is fundamentally incompatible with the aim of
 53 | protecting users' freedom to change the software.  The systematic
 54 | pattern of such abuse occurs in the area of products for individuals to
 55 | use, which is precisely where it is most unacceptable.  Therefore, we
 56 | have designed this version of the GPL to prohibit the practice for those
 57 | products.  If such problems arise substantially in other domains, we
 58 | stand ready to extend this provision to those domains in future versions
 59 | of the GPL, as needed to protect the freedom of users.
 60 | 
 61 |   Finally, every program is threatened constantly by software patents.
 62 | States should not allow patents to restrict development and use of
 63 | software on general-purpose computers, but in those that do, we wish to
 64 | avoid the special danger that patents applied to a free program could
 65 | make it effectively proprietary.  To prevent this, the GPL assures that
 66 | patents cannot be used to render the program non-free.
 67 | 
 68 |   The precise terms and conditions for copying, distribution and
 69 | modification follow.
 70 | 
 71 |                        TERMS AND CONDITIONS
 72 | 
 73 |   0. Definitions.
 74 | 
 75 |   "This License" refers to version 3 of the GNU General Public License.
 76 | 
 77 |   "Copyright" also means copyright-like laws that apply to other kinds of
 78 | works, such as semiconductor masks.
 79 | 
 80 |   "The Program" refers to any copyrightable work licensed under this
 81 | License.  Each licensee is addressed as "you".  "Licensees" and
 82 | "recipients" may be individuals or organizations.
 83 | 
 84 |   To "modify" a work means to copy from or adapt all or part of the work
 85 | in a fashion requiring copyright permission, other than the making of an
 86 | exact copy.  The resulting work is called a "modified version" of the
 87 | earlier work or a work "based on" the earlier work.
 88 | 
 89 |   A "covered work" means either the unmodified Program or a work based
 90 | on the Program.
 91 | 
 92 |   To "propagate" a work means to do anything with it that, without
 93 | permission, would make you directly or secondarily liable for
 94 | infringement under applicable copyright law, except executing it on a
 95 | computer or modifying a private copy.  Propagation includes copying,
 96 | distribution (with or without modification), making available to the
 97 | public, and in some countries other activities as well.
 98 | 
 99 |   To "convey" a work means any kind of propagation that enables other
100 | parties to make or receive copies.  Mere interaction with a user through
101 | a computer network, with no transfer of a copy, is not conveying.
102 | 
103 |   An interactive user interface displays "Appropriate Legal Notices"
104 | to the extent that it includes a convenient and prominently visible
105 | feature that (1) displays an appropriate copyright notice, and (2)
106 | tells the user that there is no warranty for the work (except to the
107 | extent that warranties are provided), that licensees may convey the
108 | work under this License, and how to view a copy of this License.  If
109 | the interface presents a list of user commands or options, such as a
110 | menu, a prominent item in the list meets this criterion.
111 | 
112 |   1. Source Code.
113 | 
114 |   The "source code" for a work means the preferred form of the work
115 | for making modifications to it.  "Object code" means any non-source
116 | form of a work.
117 | 
118 |   A "Standard Interface" means an interface that either is an official
119 | standard defined by a recognized standards body, or, in the case of
120 | interfaces specified for a particular programming language, one that
121 | is widely used among developers working in that language.
122 | 
123 |   The "System Libraries" of an executable work include anything, other
124 | than the work as a whole, that (a) is included in the normal form of
125 | packaging a Major Component, but which is not part of that Major
126 | Component, and (b) serves only to enable use of the work with that
127 | Major Component, or to implement a Standard Interface for which an
128 | implementation is available to the public in source code form.  A
129 | "Major Component", in this context, means a major essential component
130 | (kernel, window system, and so on) of the specific operating system
131 | (if any) on which the executable work runs, or a compiler used to
132 | produce the work, or an object code interpreter used to run it.
133 | 
134 |   The "Corresponding Source" for a work in object code form means all
135 | the source code needed to generate, install, and (for an executable
136 | work) run the object code and to modify the work, including scripts to
137 | control those activities.  However, it does not include the work's
138 | System Libraries, or general-purpose tools or generally available free
139 | programs which are used unmodified in performing those activities but
140 | which are not part of the work.  For example, Corresponding Source
141 | includes interface definition files associated with source files for
142 | the work, and the source code for shared libraries and dynamically
143 | linked subprograms that the work is specifically designed to require,
144 | such as by intimate data communication or control flow between those
145 | subprograms and other parts of the work.
146 | 
147 |   The Corresponding Source need not include anything that users
148 | can regenerate automatically from other parts of the Corresponding
149 | Source.
150 | 
151 |   The Corresponding Source for a work in source code form is that
152 | same work.
153 | 
154 |   2. Basic Permissions.
155 | 
156 |   All rights granted under this License are granted for the term of
157 | copyright on the Program, and are irrevocable provided the stated
158 | conditions are met.  This License explicitly affirms your unlimited
159 | permission to run the unmodified Program.  The output from running a
160 | covered work is covered by this License only if the output, given its
161 | content, constitutes a covered work.  This License acknowledges your
162 | rights of fair use or other equivalent, as provided by copyright law.
163 | 
164 |   You may make, run and propagate covered works that you do not
165 | convey, without conditions so long as your license otherwise remains
166 | in force.  You may convey covered works to others for the sole purpose
167 | of having them make modifications exclusively for you, or provide you
168 | with facilities for running those works, provided that you comply with
169 | the terms of this License in conveying all material for which you do
170 | not control copyright.  Those thus making or running the covered works
171 | for you must do so exclusively on your behalf, under your direction
172 | and control, on terms that prohibit them from making any copies of
173 | your copyrighted material outside their relationship with you.
174 | 
175 |   Conveying under any other circumstances is permitted solely under
176 | the conditions stated below.  Sublicensing is not allowed; section 10
177 | makes it unnecessary.
178 | 
179 |   3. Protecting Users' Legal Rights From Anti-Circumvention Law.
180 | 
181 |   No covered work shall be deemed part of an effective technological
182 | measure under any applicable law fulfilling obligations under article
183 | 11 of the WIPO copyright treaty adopted on 20 December 1996, or
184 | similar laws prohibiting or restricting circumvention of such
185 | measures.
186 | 
187 |   When you convey a covered work, you waive any legal power to forbid
188 | circumvention of technological measures to the extent such circumvention
189 | is effected by exercising rights under this License with respect to
190 | the covered work, and you disclaim any intention to limit operation or
191 | modification of the work as a means of enforcing, against the work's
192 | users, your or third parties' legal rights to forbid circumvention of
193 | technological measures.
194 | 
195 |   4. Conveying Verbatim Copies.
196 | 
197 |   You may convey verbatim copies of the Program's source code as you
198 | receive it, in any medium, provided that you conspicuously and
199 | appropriately publish on each copy an appropriate copyright notice;
200 | keep intact all notices stating that this License and any
201 | non-permissive terms added in accord with section 7 apply to the code;
202 | keep intact all notices of the absence of any warranty; and give all
203 | recipients a copy of this License along with the Program.
204 | 
205 |   You may charge any price or no price for each copy that you convey,
206 | and you may offer support or warranty protection for a fee.
207 | 
208 |   5. Conveying Modified Source Versions.
209 | 
210 |   You may convey a work based on the Program, or the modifications to
211 | produce it from the Program, in the form of source code under the
212 | terms of section 4, provided that you also meet all of these conditions:
213 | 
214 |     a) The work must carry prominent notices stating that you modified
215 |     it, and giving a relevant date.
216 | 
217 |     b) The work must carry prominent notices stating that it is
218 |     released under this License and any conditions added under section
219 |     7.  This requirement modifies the requirement in section 4 to
220 |     "keep intact all notices".
221 | 
222 |     c) You must license the entire work, as a whole, under this
223 |     License to anyone who comes into possession of a copy.  This
224 |     License will therefore apply, along with any applicable section 7
225 |     additional terms, to the whole of the work, and all its parts,
226 |     regardless of how they are packaged.  This License gives no
227 |     permission to license the work in any other way, but it does not
228 |     invalidate such permission if you have separately received it.
229 | 
230 |     d) If the work has interactive user interfaces, each must display
231 |     Appropriate Legal Notices; however, if the Program has interactive
232 |     interfaces that do not display Appropriate Legal Notices, your
233 |     work need not make them do so.
234 | 
235 |   A compilation of a covered work with other separate and independent
236 | works, which are not by their nature extensions of the covered work,
237 | and which are not combined with it such as to form a larger program,
238 | in or on a volume of a storage or distribution medium, is called an
239 | "aggregate" if the compilation and its resulting copyright are not
240 | used to limit the access or legal rights of the compilation's users
241 | beyond what the individual works permit.  Inclusion of a covered work
242 | in an aggregate does not cause this License to apply to the other
243 | parts of the aggregate.
244 | 
245 |   6. Conveying Non-Source Forms.
246 | 
247 |   You may convey a covered work in object code form under the terms
248 | of sections 4 and 5, provided that you also convey the
249 | machine-readable Corresponding Source under the terms of this License,
250 | in one of these ways:
251 | 
252 |     a) Convey the object code in, or embodied in, a physical product
253 |     (including a physical distribution medium), accompanied by the
254 |     Corresponding Source fixed on a durable physical medium
255 |     customarily used for software interchange.
256 | 
257 |     b) Convey the object code in, or embodied in, a physical product
258 |     (including a physical distribution medium), accompanied by a
259 |     written offer, valid for at least three years and valid for as
260 |     long as you offer spare parts or customer support for that product
261 |     model, to give anyone who possesses the object code either (1) a
262 |     copy of the Corresponding Source for all the software in the
263 |     product that is covered by this License, on a durable physical
264 |     medium customarily used for software interchange, for a price no
265 |     more than your reasonable cost of physically performing this
266 |     conveying of source, or (2) access to copy the
267 |     Corresponding Source from a network server at no charge.
268 | 
269 |     c) Convey individual copies of the object code with a copy of the
270 |     written offer to provide the Corresponding Source.  This
271 |     alternative is allowed only occasionally and noncommercially, and
272 |     only if you received the object code with such an offer, in accord
273 |     with subsection 6b.
274 | 
275 |     d) Convey the object code by offering access from a designated
276 |     place (gratis or for a charge), and offer equivalent access to the
277 |     Corresponding Source in the same way through the same place at no
278 |     further charge.  You need not require recipients to copy the
279 |     Corresponding Source along with the object code.  If the place to
280 |     copy the object code is a network server, the Corresponding Source
281 |     may be on a different server (operated by you or a third party)
282 |     that supports equivalent copying facilities, provided you maintain
283 |     clear directions next to the object code saying where to find the
284 |     Corresponding Source.  Regardless of what server hosts the
285 |     Corresponding Source, you remain obligated to ensure that it is
286 |     available for as long as needed to satisfy these requirements.
287 | 
288 |     e) Convey the object code using peer-to-peer transmission, provided
289 |     you inform other peers where the object code and Corresponding
290 |     Source of the work are being offered to the general public at no
291 |     charge under subsection 6d.
292 | 
293 |   A separable portion of the object code, whose source code is excluded
294 | from the Corresponding Source as a System Library, need not be
295 | included in conveying the object code work.
296 | 
297 |   A "User Product" is either (1) a "consumer product", which means any
298 | tangible personal property which is normally used for personal, family,
299 | or household purposes, or (2) anything designed or sold for incorporation
300 | into a dwelling.  In determining whether a product is a consumer product,
301 | doubtful cases shall be resolved in favor of coverage.  For a particular
302 | product received by a particular user, "normally used" refers to a
303 | typical or common use of that class of product, regardless of the status
304 | of the particular user or of the way in which the particular user
305 | actually uses, or expects or is expected to use, the product.  A product
306 | is a consumer product regardless of whether the product has substantial
307 | commercial, industrial or non-consumer uses, unless such uses represent
308 | the only significant mode of use of the product.
309 | 
310 |   "Installation Information" for a User Product means any methods,
311 | procedures, authorization keys, or other information required to install
312 | and execute modified versions of a covered work in that User Product from
313 | a modified version of its Corresponding Source.  The information must
314 | suffice to ensure that the continued functioning of the modified object
315 | code is in no case prevented or interfered with solely because
316 | modification has been made.
317 | 
318 |   If you convey an object code work under this section in, or with, or
319 | specifically for use in, a User Product, and the conveying occurs as
320 | part of a transaction in which the right of possession and use of the
321 | User Product is transferred to the recipient in perpetuity or for a
322 | fixed term (regardless of how the transaction is characterized), the
323 | Corresponding Source conveyed under this section must be accompanied
324 | by the Installation Information.  But this requirement does not apply
325 | if neither you nor any third party retains the ability to install
326 | modified object code on the User Product (for example, the work has
327 | been installed in ROM).
328 | 
329 |   The requirement to provide Installation Information does not include a
330 | requirement to continue to provide support service, warranty, or updates
331 | for a work that has been modified or installed by the recipient, or for
332 | the User Product in which it has been modified or installed.  Access to a
333 | network may be denied when the modification itself materially and
334 | adversely affects the operation of the network or violates the rules and
335 | protocols for communication across the network.
336 | 
337 |   Corresponding Source conveyed, and Installation Information provided,
338 | in accord with this section must be in a format that is publicly
339 | documented (and with an implementation available to the public in
340 | source code form), and must require no special password or key for
341 | unpacking, reading or copying.
342 | 
343 |   7. Additional Terms.
344 | 
345 |   "Additional permissions" are terms that supplement the terms of this
346 | License by making exceptions from one or more of its conditions.
347 | Additional permissions that are applicable to the entire Program shall
348 | be treated as though they were included in this License, to the extent
349 | that they are valid under applicable law.  If additional permissions
350 | apply only to part of the Program, that part may be used separately
351 | under those permissions, but the entire Program remains governed by
352 | this License without regard to the additional permissions.
353 | 
354 |   When you convey a copy of a covered work, you may at your option
355 | remove any additional permissions from that copy, or from any part of
356 | it.  (Additional permissions may be written to require their own
357 | removal in certain cases when you modify the work.)  You may place
358 | additional permissions on material, added by you to a covered work,
359 | for which you have or can give appropriate copyright permission.
360 | 
361 |   Notwithstanding any other provision of this License, for material you
362 | add to a covered work, you may (if authorized by the copyright holders of
363 | that material) supplement the terms of this License with terms:
364 | 
365 |     a) Disclaiming warranty or limiting liability differently from the
366 |     terms of sections 15 and 16 of this License; or
367 | 
368 |     b) Requiring preservation of specified reasonable legal notices or
369 |     author attributions in that material or in the Appropriate Legal
370 |     Notices displayed by works containing it; or
371 | 
372 |     c) Prohibiting misrepresentation of the origin of that material, or
373 |     requiring that modified versions of such material be marked in
374 |     reasonable ways as different from the original version; or
375 | 
376 |     d) Limiting the use for publicity purposes of names of licensors or
377 |     authors of the material; or
378 | 
379 |     e) Declining to grant rights under trademark law for use of some
380 |     trade names, trademarks, or service marks; or
381 | 
382 |     f) Requiring indemnification of licensors and authors of that
383 |     material by anyone who conveys the material (or modified versions of
384 |     it) with contractual assumptions of liability to the recipient, for
385 |     any liability that these contractual assumptions directly impose on
386 |     those licensors and authors.
387 | 
388 |   All other non-permissive additional terms are considered "further
389 | restrictions" within the meaning of section 10.  If the Program as you
390 | received it, or any part of it, contains a notice stating that it is
391 | governed by this License along with a term that is a further
392 | restriction, you may remove that term.  If a license document contains
393 | a further restriction but permits relicensing or conveying under this
394 | License, you may add to a covered work material governed by the terms
395 | of that license document, provided that the further restriction does
396 | not survive such relicensing or conveying.
397 | 
398 |   If you add terms to a covered work in accord with this section, you
399 | must place, in the relevant source files, a statement of the
400 | additional terms that apply to those files, or a notice indicating
401 | where to find the applicable terms.
402 | 
403 |   Additional terms, permissive or non-permissive, may be stated in the
404 | form of a separately written license, or stated as exceptions;
405 | the above requirements apply either way.
406 | 
407 |   8. Termination.
408 | 
409 |   You may not propagate or modify a covered work except as expressly
410 | provided under this License.  Any attempt otherwise to propagate or
411 | modify it is void, and will automatically terminate your rights under
412 | this License (including any patent licenses granted under the third
413 | paragraph of section 11).
414 | 
415 |   However, if you cease all violation of this License, then your
416 | license from a particular copyright holder is reinstated (a)
417 | provisionally, unless and until the copyright holder explicitly and
418 | finally terminates your license, and (b) permanently, if the copyright
419 | holder fails to notify you of the violation by some reasonable means
420 | prior to 60 days after the cessation.
421 | 
422 |   Moreover, your license from a particular copyright holder is
423 | reinstated permanently if the copyright holder notifies you of the
424 | violation by some reasonable means, this is the first time you have
425 | received notice of violation of this License (for any work) from that
426 | copyright holder, and you cure the violation prior to 30 days after
427 | your receipt of the notice.
428 | 
429 |   Termination of your rights under this section does not terminate the
430 | licenses of parties who have received copies or rights from you under
431 | this License.  If your rights have been terminated and not permanently
432 | reinstated, you do not qualify to receive new licenses for the same
433 | material under section 10.
434 | 
435 |   9. Acceptance Not Required for Having Copies.
436 | 
437 |   You are not required to accept this License in order to receive or
438 | run a copy of the Program.  Ancillary propagation of a covered work
439 | occurring solely as a consequence of using peer-to-peer transmission
440 | to receive a copy likewise does not require acceptance.  However,
441 | nothing other than this License grants you permission to propagate or
442 | modify any covered work.  These actions infringe copyright if you do
443 | not accept this License.  Therefore, by modifying or propagating a
444 | covered work, you indicate your acceptance of this License to do so.
445 | 
446 |   10. Automatic Licensing of Downstream Recipients.
447 | 
448 |   Each time you convey a covered work, the recipient automatically
449 | receives a license from the original licensors, to run, modify and
450 | propagate that work, subject to this License.  You are not responsible
451 | for enforcing compliance by third parties with this License.
452 | 
453 |   An "entity transaction" is a transaction transferring control of an
454 | organization, or substantially all assets of one, or subdividing an
455 | organization, or merging organizations.  If propagation of a covered
456 | work results from an entity transaction, each party to that
457 | transaction who receives a copy of the work also receives whatever
458 | licenses to the work the party's predecessor in interest had or could
459 | give under the previous paragraph, plus a right to possession of the
460 | Corresponding Source of the work from the predecessor in interest, if
461 | the predecessor has it or can get it with reasonable efforts.
462 | 
463 |   You may not impose any further restrictions on the exercise of the
464 | rights granted or affirmed under this License.  For example, you may
465 | not impose a license fee, royalty, or other charge for exercise of
466 | rights granted under this License, and you may not initiate litigation
467 | (including a cross-claim or counterclaim in a lawsuit) alleging that
468 | any patent claim is infringed by making, using, selling, offering for
469 | sale, or importing the Program or any portion of it.
470 | 
471 |   11. Patents.
472 | 
473 |   A "contributor" is a copyright holder who authorizes use under this
474 | License of the Program or a work on which the Program is based.  The
475 | work thus licensed is called the contributor's "contributor version".
476 | 
477 |   A contributor's "essential patent claims" are all patent claims
478 | owned or controlled by the contributor, whether already acquired or
479 | hereafter acquired, that would be infringed by some manner, permitted
480 | by this License, of making, using, or selling its contributor version,
481 | but do not include claims that would be infringed only as a
482 | consequence of further modification of the contributor version.  For
483 | purposes of this definition, "control" includes the right to grant
484 | patent sublicenses in a manner consistent with the requirements of
485 | this License.
486 | 
487 |   Each contributor grants you a non-exclusive, worldwide, royalty-free
488 | patent license under the contributor's essential patent claims, to
489 | make, use, sell, offer for sale, import and otherwise run, modify and
490 | propagate the contents of its contributor version.
491 | 
492 |   In the following three paragraphs, a "patent license" is any express
493 | agreement or commitment, however denominated, not to enforce a patent
494 | (such as an express permission to practice a patent or covenant not to
495 | sue for patent infringement).  To "grant" such a patent license to a
496 | party means to make such an agreement or commitment not to enforce a
497 | patent against the party.
498 | 
499 |   If you convey a covered work, knowingly relying on a patent license,
500 | and the Corresponding Source of the work is not available for anyone
501 | to copy, free of charge and under the terms of this License, through a
502 | publicly available network server or other readily accessible means,
503 | then you must either (1) cause the Corresponding Source to be so
504 | available, or (2) arrange to deprive yourself of the benefit of the
505 | patent license for this particular work, or (3) arrange, in a manner
506 | consistent with the requirements of this License, to extend the patent
507 | license to downstream recipients.  "Knowingly relying" means you have
508 | actual knowledge that, but for the patent license, your conveying the
509 | covered work in a country, or your recipient's use of the covered work
510 | in a country, would infringe one or more identifiable patents in that
511 | country that you have reason to believe are valid.
512 | 
513 |   If, pursuant to or in connection with a single transaction or
514 | arrangement, you convey, or propagate by procuring conveyance of, a
515 | covered work, and grant a patent license to some of the parties
516 | receiving the covered work authorizing them to use, propagate, modify
517 | or convey a specific copy of the covered work, then the patent license
518 | you grant is automatically extended to all recipients of the covered
519 | work and works based on it.
520 | 
521 |   A patent license is "discriminatory" if it does not include within
522 | the scope of its coverage, prohibits the exercise of, or is
523 | conditioned on the non-exercise of one or more of the rights that are
524 | specifically granted under this License.  You may not convey a covered
525 | work if you are a party to an arrangement with a third party that is
526 | in the business of distributing software, under which you make payment
527 | to the third party based on the extent of your activity of conveying
528 | the work, and under which the third party grants, to any of the
529 | parties who would receive the covered work from you, a discriminatory
530 | patent license (a) in connection with copies of the covered work
531 | conveyed by you (or copies made from those copies), or (b) primarily
532 | for and in connection with specific products or compilations that
533 | contain the covered work, unless you entered into that arrangement,
534 | or that patent license was granted, prior to 28 March 2007.
535 | 
536 |   Nothing in this License shall be construed as excluding or limiting
537 | any implied license or other defenses to infringement that may
538 | otherwise be available to you under applicable patent law.
539 | 
540 |   12. No Surrender of Others' Freedom.
541 | 
542 |   If conditions are imposed on you (whether by court order, agreement or
543 | otherwise) that contradict the conditions of this License, they do not
544 | excuse you from the conditions of this License.  If you cannot convey a
545 | covered work so as to satisfy simultaneously your obligations under this
546 | License and any other pertinent obligations, then as a consequence you may
547 | not convey it at all.  For example, if you agree to terms that obligate you
548 | to collect a royalty for further conveying from those to whom you convey
549 | the Program, the only way you could satisfy both those terms and this
550 | License would be to refrain entirely from conveying the Program.
551 | 
552 |   13. Use with the GNU Affero General Public License.
553 | 
554 |   Notwithstanding any other provision of this License, you have
555 | permission to link or combine any covered work with a work licensed
556 | under version 3 of the GNU Affero General Public License into a single
557 | combined work, and to convey the resulting work.  The terms of this
558 | License will continue to apply to the part which is the covered work,
559 | but the special requirements of the GNU Affero General Public License,
560 | section 13, concerning interaction through a network will apply to the
561 | combination as such.
562 | 
563 |   14. Revised Versions of this License.
564 | 
565 |   The Free Software Foundation may publish revised and/or new versions of
566 | the GNU General Public License from time to time.  Such new versions will
567 | be similar in spirit to the present version, but may differ in detail to
568 | address new problems or concerns.
569 | 
570 |   Each version is given a distinguishing version number.  If the
571 | Program specifies that a certain numbered version of the GNU General
572 | Public License "or any later version" applies to it, you have the
573 | option of following the terms and conditions either of that numbered
574 | version or of any later version published by the Free Software
575 | Foundation.  If the Program does not specify a version number of the
576 | GNU General Public License, you may choose any version ever published
577 | by the Free Software Foundation.
578 | 
579 |   If the Program specifies that a proxy can decide which future
580 | versions of the GNU General Public License can be used, that proxy's
581 | public statement of acceptance of a version permanently authorizes you
582 | to choose that version for the Program.
583 | 
584 |   Later license versions may give you additional or different
585 | permissions.  However, no additional obligations are imposed on any
586 | author or copyright holder as a result of your choosing to follow a
587 | later version.
588 | 
589 |   15. Disclaimer of Warranty.
590 | 
591 |   THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
592 | APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
593 | HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
594 | OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
595 | THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
596 | PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
597 | IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
598 | ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
599 | 
600 |   16. Limitation of Liability.
601 | 
602 |   IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
603 | WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
604 | THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
605 | GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
606 | USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
607 | DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
608 | PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
609 | EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
610 | SUCH DAMAGES.
611 | 
612 |   17. Interpretation of Sections 15 and 16.
613 | 
614 |   If the disclaimer of warranty and limitation of liability provided
615 | above cannot be given local legal effect according to their terms,
616 | reviewing courts shall apply local law that most closely approximates
617 | an absolute waiver of all civil liability in connection with the
618 | Program, unless a warranty or assumption of liability accompanies a
619 | copy of the Program in return for a fee.
620 | 
621 |                      END OF TERMS AND CONDITIONS
622 | 
623 |             How to Apply These Terms to Your New Programs
624 | 
625 |   If you develop a new program, and you want it to be of the greatest
626 | possible use to the public, the best way to achieve this is to make it
627 | free software which everyone can redistribute and change under these terms.
628 | 
629 |   To do so, attach the following notices to the program.  It is safest
630 | to attach them to the start of each source file to most effectively
631 | state the exclusion of warranty; and each file should have at least
632 | the "copyright" line and a pointer to where the full notice is found.
633 | 
634 |     <one line to give the program's name and a brief idea of what it does.>
635 |     Copyright (C) <year>  <name of author>
636 | 
637 |     This program is free software: you can redistribute it and/or modify
638 |     it under the terms of the GNU General Public License as published by
639 |     the Free Software Foundation, either version 3 of the License, or
640 |     (at your option) any later version.
641 | 
642 |     This program is distributed in the hope that it will be useful,
643 |     but WITHOUT ANY WARRANTY; without even the implied warranty of
644 |     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
645 |     GNU General Public License for more details.
646 | 
647 |     You should have received a copy of the GNU General Public License
648 |     along with this program.  If not, see <https://www.gnu.org/licenses/>.
649 | 
650 | Also add information on how to contact you by electronic and paper mail.
651 | 
652 |   If the program does terminal interaction, make it output a short
653 | notice like this when it starts in an interactive mode:
654 | 
655 |     <program>  Copyright (C) <year>  <name of author>
656 |     This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
657 |     This is free software, and you are welcome to redistribute it
658 |     under certain conditions; type `show c' for details.
659 | 
660 | The hypothetical commands `show w' and `show c' should show the appropriate
661 | parts of the General Public License.  Of course, your program's commands
662 | might be different; for a GUI interface, you would use an "about box".
663 | 
664 |   You should also get your employer (if you work as a programmer) or school,
665 | if any, to sign a "copyright disclaimer" for the program, if necessary.
666 | For more information on this, and how to apply and follow the GNU GPL, see
667 | <https://www.gnu.org/licenses/>.
668 | 
669 |   The GNU General Public License does not permit incorporating your program
670 | into proprietary programs.  If your program is a subroutine library, you
671 | may consider it more useful to permit linking proprietary applications with
672 | the library.  If this is what you want to do, use the GNU Lesser General
673 | Public License instead of this License.  But first, please read
674 | <https://www.gnu.org/licenses/why-not-lgpl.html>.
675 | 


--------------------------------------------------------------------------------