@adland/data 0.2.0

package/.eslintrc.js

@@ -0,0 +1,35 @@
+const { resolve } = require("node:path");
+
+const project = resolve(process.cwd(), "tsconfig.json");
+
+/** @type {import("eslint").Linter.Config} */
+module.exports = {
+  extends: ["eslint:recommended", "turbo"],
+  plugins: ["only-warn"],
+  globals: {
+    React: true,
+    JSX: true,
+  },
+  env: {
+    node: true,
+  },
+  settings: {
+    "import/resolver": {
+      typescript: {
+        project,
+      },
+    },
+  },
+  ignorePatterns: [
+    // Ignore dotfiles
+    ".*.js",
+    "node_modules/",
+    "dist/",
+  ],
+  overrides: [
+    {
+      files: ["*.js?(x)", "*.ts?(x)"],
+    },
+  ],
+};
+

package/CHANGELOG.md

@@ -0,0 +1,7 @@
+# @adland/data
+
+## 0.2.0
+
+### Minor Changes
+
+- 5f947df: initial push of data package

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 dan5py (git@dan5py.com)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,218 @@
+# @adland/data
+
+TypeScript types and Zod schemas for AdLand ad types. Perfect for building forms with react-hook-form, validating data, and type-safe ad handling.
+
+## Installation
+
+```bash
+npm install @adland/data
+# or
+pnpm add @adland/data
+# or
+yarn add @adland/data
+```
+
+## Usage
+
+### TypeScript Types
+
+Types are automatically derived from Zod schemas, ensuring type safety:
+
+```tsx
+import type { AdData, LinkAd, SwapAd } from "@adland/data";
+
+// Use the types
+const linkAd: LinkAd = {
+  type: "link",
+  url: "https://example.com",
+};
+
+const swapAd: SwapAd = {
+  type: "swap",
+  fromToken: "USDC",
+  toToken: "ETH",
+  amount: "100",
+};
+```
+
+### Zod Schemas
+
+Use Zod schemas for validation and form integration:
+
+```tsx
+import { linkAdSchema, swapAdSchema, validateAdData } from "@adland/data";
+import { useForm } from "react-hook-form";
+import { zodResolver } from "@hookform/resolvers/zod";
+
+// With react-hook-form
+function MyForm() {
+  const form = useForm({
+    resolver: zodResolver(swapAdSchema),
+  });
+  
+  // ... rest of form
+}
+
+// Direct validation
+const result = validateAdData(someData);
+if (result.success) {
+  console.log("Valid ad data:", result.data);
+} else {
+  console.error("Validation errors:", result.error);
+}
+```
+
+### Combining Schemas
+
+Zod makes it easy to extend and combine schemas:
+
+```tsx
+import { linkAdSchema } from "@adland/data";
+import { z } from "zod";
+
+// Extend a schema
+const customLinkSchema = linkAdSchema.extend({
+  title: z.string(),
+  description: z.string().optional(),
+});
+
+// Combine schemas
+const adWithMetadata = z.intersection(
+  linkAdSchema,
+  z.object({ metadata: z.record(z.unknown()) })
+);
+```
+
+## Ad Types
+
+### Link Ad
+Basic link ad type.
+
+```typescript
+type LinkAd = {
+  type: "link";
+  url: string;
+}
+```
+
+### Cast Ad
+Farcaster cast link ad type.
+
+```typescript
+type CastAd = {
+  type: "cast";
+  url: string;
+}
+```
+
+### MiniApp Ad
+Farcaster mini app link ad type.
+
+```typescript
+type MiniAppAd = {
+  type: "miniapp";
+  url: string;
+}
+```
+
+### Token Ad
+Token information ad type.
+
+```typescript
+type TokenAd = {
+  type: "token";
+  token: string; // Token address or symbol
+}
+```
+
+### Swap Ad
+Token swap ad type.
+
+```typescript
+type SwapAd = {
+  type: "swap";
+  fromToken: string; // Token address or symbol
+  toToken: string; // Token address or symbol
+  amount?: string; // Optional amount
+}
+```
+
+## API
+
+### Types
+
+- `AdType` - Union type of all ad type strings
+- `AdData` - Union type of all ad data objects (discriminated union)
+- `LinkAd` - Link ad type
+- `CastAd` - Cast ad type
+- `MiniAppAd` - MiniApp ad type
+- `TokenAd` - Token ad type
+- `SwapAd` - Swap ad type
+
+### Schemas
+
+- `linkAdSchema` - Zod schema for link ads
+- `castAdSchema` - Zod schema for cast ads
+- `miniappAdSchema` - Zod schema for mini app ads
+- `tokenAdSchema` - Zod schema for token ads
+- `swapAdSchema` - Zod schema for swap ads
+- `adDataSchema` - Discriminated union schema for all ad types
+- `adSchemas` - Object containing all schemas
+- `getAdSchema(type)` - Get schema for a specific ad type
+- `getAllAdSchemas()` - Get all ad schemas
+- `validateAdData(data)` - Validate ad data and return result
+
+## Integration Examples
+
+### React Hook Form
+
+```tsx
+import { useForm } from "react-hook-form";
+import { zodResolver } from "@hookform/resolvers/zod";
+import { swapAdSchema, type SwapAd } from "@adland/data";
+
+function SwapForm() {
+  const form = useForm<SwapAd>({
+    resolver: zodResolver(swapAdSchema),
+    defaultValues: {
+      type: "swap",
+      fromToken: "",
+      toToken: "",
+    },
+  });
+  
+  return (
+    <form onSubmit={form.handleSubmit(onSubmit)}>
+      {/* form fields */}
+    </form>
+  );
+}
+```
+
+### Formik
+
+```tsx
+import { Formik } from "formik";
+import { swapAdSchema } from "@adland/data";
+import { toFormikValidationSchema } from "zod-formik-adapter";
+
+function SwapForm() {
+  return (
+    <Formik
+      validationSchema={toFormikValidationSchema(swapAdSchema)}
+      initialValues={{
+        type: "swap" as const,
+        fromToken: "",
+        toToken: "",
+      }}
+      onSubmit={handleSubmit}
+    >
+      {/* form */}
+    </Formik>
+  );
+}
+```
+
+## License
+
+MIT

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@adland/data",
+  "version": "0.2.0",
+  "private": false,
+  "publishConfig": {
+    "access": "public"
+  },
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    },
+    "./package.json": "./package.json"
+  },
+  "dependencies": {
+    "zod": "^3.24.2"
+  },
+  "devDependencies": {
+    "@types/node": "^20",
+    "@typescript-eslint/eslint-plugin": "^7.13.1",
+    "@typescript-eslint/parser": "^7.13.1",
+    "@vercel/style-guide": "^6.0.0",
+    "eslint": "^8",
+    "eslint-config-turbo": "2.0.6",
+    "eslint-plugin-only-warn": "^1.1.0",
+    "tsup": "^8.0.1",
+    "typescript": "^5.4.5"
+  },
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "lint": "eslint ."
+  }
+}

package/src/index.ts

@@ -0,0 +1,24 @@
+// Export types (derived from Zod schemas)
+export type {
+  AdType,
+  AdData,
+  LinkAd,
+  CastAd,
+  MiniAppAd,
+  TokenAd,
+  SwapAd,
+} from "./types";
+
+// Export Zod schemas
+export {
+  linkAdSchema,
+  castAdSchema,
+  miniappAdSchema,
+  tokenAdSchema,
+  swapAdSchema,
+  adDataSchema,
+  adSchemas,
+  getAdSchema,
+  getAllAdSchemas,
+  validateAdData,
+} from "./schemas";

package/src/schemas/index.ts

@@ -0,0 +1,94 @@
+import { z } from "zod";
+
+/**
+ * Link ad schema - basic link
+ */
+export const linkAdSchema = z.object({
+  type: z.literal("link"),
+  url: z.string().url("Must be a valid URL"),
+});
+
+/**
+ * Cast ad schema - link to a Farcaster cast
+ */
+export const castAdSchema = z.object({
+  type: z.literal("cast"),
+  url: z.string().url("Must be a valid URL"),
+});
+
+/**
+ * MiniApp ad schema - link to a Farcaster mini app
+ */
+export const miniappAdSchema = z.object({
+  type: z.literal("miniapp"),
+  url: z.string().url("Must be a valid URL"),
+});
+
+/**
+ * Token ad schema - token information
+ */
+export const tokenAdSchema = z.object({
+  type: z.literal("token"),
+  token: z.string().min(1, "Token is required"),
+});
+
+/**
+ * Swap ad schema - token swap information
+ */
+export const swapAdSchema = z.object({
+  type: z.literal("swap"),
+  fromToken: z.string().min(1, "From token is required"),
+  toToken: z.string().min(1, "To token is required"),
+  amount: z.string().optional(),
+});
+
+/**
+ * Union schema for all ad types
+ */
+export const adDataSchema = z.discriminatedUnion("type", [
+  linkAdSchema,
+  castAdSchema,
+  miniappAdSchema,
+  tokenAdSchema,
+  swapAdSchema,
+]);
+
+/**
+ * All ad schemas as an object
+ */
+export const adSchemas = {
+  link: linkAdSchema,
+  cast: castAdSchema,
+  miniapp: miniappAdSchema,
+  token: tokenAdSchema,
+  swap: swapAdSchema,
+} as const;
+
+/**
+ * Get schema for a specific ad type
+ */
+export function getAdSchema(type: keyof typeof adSchemas) {
+  return adSchemas[type];
+}
+
+/**
+ * Get all ad schemas
+ */
+export function getAllAdSchemas() {
+  return adSchemas;
+}
+
+/**
+ * Validate ad data
+ */
+export function validateAdData(data: unknown): {
+  success: boolean;
+  data?: z.infer<typeof adDataSchema>;
+  error?: z.ZodError;
+} {
+  const result = adDataSchema.safeParse(data);
+  if (result.success) {
+    return { success: true, data: result.data };
+  }
+  return { success: false, error: result.error };
+}

package/src/types/index.ts

@@ -0,0 +1,44 @@
+import { z } from "zod";
+import {
+  linkAdSchema,
+  castAdSchema,
+  miniappAdSchema,
+  tokenAdSchema,
+  swapAdSchema,
+  adDataSchema,
+} from "../schemas";
+
+/**
+ * Base ad type
+ */
+export type AdType = "link" | "cast" | "miniapp" | "token" | "swap";
+
+/**
+ * Link ad type - basic link
+ */
+export type LinkAd = z.infer<typeof linkAdSchema>;
+
+/**
+ * Cast ad type - link to a Farcaster cast
+ */
+export type CastAd = z.infer<typeof castAdSchema>;
+
+/**
+ * MiniApp ad type - link to a Farcaster mini app
+ */
+export type MiniAppAd = z.infer<typeof miniappAdSchema>;
+
+/**
+ * Token ad type - token information
+ */
+export type TokenAd = z.infer<typeof tokenAdSchema>;
+
+/**
+ * Swap ad type - token swap information
+ */
+export type SwapAd = z.infer<typeof swapAdSchema>;
+
+/**
+ * Union type of all ad types
+ */
+export type AdData = z.infer<typeof adDataSchema>;

package/tsconfig.json

@@ -0,0 +1,27 @@
+{
+  "$schema": "https://json.schemastore.org/tsconfig",
+  "compilerOptions": {
+    "declaration": true,
+    "declarationMap": true,
+    "esModuleInterop": true,
+    "incremental": false,
+    "isolatedModules": true,
+    "lib": ["es2022"],
+    "module": "ESNext",
+    "moduleDetection": "force",
+    "moduleResolution": "bundler",
+    "noUncheckedIndexedAccess": true,
+    "resolveJsonModule": true,
+    "skipLibCheck": true,
+    "strict": true,
+    "target": "ES2022",
+    "baseUrl": ".",
+    "paths": {
+      "@adland/data/*": ["./src/*"]
+    },
+    "outDir": "./dist"
+  },
+  "include": ["src"],
+  "exclude": ["node_modules", "dist"]
+}
+

package/tsup.config.ts

@@ -0,0 +1,12 @@
+import { defineConfig } from "tsup";
+
+export default defineConfig({
+  entry: ["src/index.ts"],
+  format: ["cjs", "esm"],
+  dts: true,
+  splitting: false,
+  sourcemap: true,
+  clean: true,
+  treeshake: true,
+});
+