@calmlens/js-sdk 0.0.0

package/esm/Classification.d.ts

@@ -0,0 +1,154 @@
+import * as zod from "zod/v4";
+export declare const CLASSIFICATION_CATEGORIES: readonly ["sexual", "violence", "gore", "self-harm", "harassment", "hate", "illicit", "child-exploitation"];
+export declare const CLASSIFICATION_CATEGORY_SCHEMA: zod.ZodEnum<{
+    sexual: "sexual";
+    violence: "violence";
+    gore: "gore";
+    "self-harm": "self-harm";
+    harassment: "harassment";
+    hate: "hate";
+    illicit: "illicit";
+    "child-exploitation": "child-exploitation";
+}>;
+export type ClassificationCategory = zod.infer<typeof CLASSIFICATION_CATEGORY_SCHEMA>;
+export declare const CLASSIFICATION_CATEGORY_INFO_SCHEMA: zod.ZodObject<{
+    category: zod.ZodEnum<{
+        sexual: "sexual";
+        violence: "violence";
+        gore: "gore";
+        "self-harm": "self-harm";
+        harassment: "harassment";
+        hate: "hate";
+        illicit: "illicit";
+        "child-exploitation": "child-exploitation";
+    }>;
+    displayName: zod.ZodPipe<zod.ZodString, zod.ZodTransform<string, string>>;
+    description: zod.ZodPipe<zod.ZodString, zod.ZodTransform<string, string>>;
+    textOnly: zod.ZodBoolean;
+    supportsImages: zod.ZodBoolean;
+}, zod.z.core.$strip>;
+export type ClassificationCategoryInfo = zod.infer<typeof CLASSIFICATION_CATEGORY_INFO_SCHEMA>;
+export declare const CLASSIFICATION_CATEGORY_INFO: Record<ClassificationCategory, ClassificationCategoryInfo>;
+export declare const getCategoryInfo: (category: ClassificationCategory) => ClassificationCategoryInfo;
+export declare const LIKELIHOOD_SCHEMA: zod.ZodEnum<{
+    VERY_UNLIKELY: "VERY_UNLIKELY";
+    UNLIKELY: "UNLIKELY";
+    POSSIBLE: "POSSIBLE";
+    LIKELY: "LIKELY";
+    VERY_LIKELY: "VERY_LIKELY";
+}>;
+export type Likelihood = zod.infer<typeof LIKELIHOOD_SCHEMA>;
+export declare const CLASSIFICATION_CATEGORY_REPORT_SCHEMA: zod.ZodObject<{
+    category: zod.ZodEnum<{
+        sexual: "sexual";
+        violence: "violence";
+        gore: "gore";
+        "self-harm": "self-harm";
+        harassment: "harassment";
+        hate: "hate";
+        illicit: "illicit";
+        "child-exploitation": "child-exploitation";
+    }>;
+    likelihood: zod.ZodEnum<{
+        VERY_UNLIKELY: "VERY_UNLIKELY";
+        UNLIKELY: "UNLIKELY";
+        POSSIBLE: "POSSIBLE";
+        LIKELY: "LIKELY";
+        VERY_LIKELY: "VERY_LIKELY";
+    }>;
+    score: zod.ZodNumber;
+}, zod.z.core.$strip>;
+export type ClassificationCategoryReport = zod.infer<typeof CLASSIFICATION_CATEGORY_REPORT_SCHEMA>;
+export declare const CATEGORIES_SCHEMA: zod.ZodRecord<zod.ZodEnum<{
+    sexual: "sexual";
+    violence: "violence";
+    gore: "gore";
+    "self-harm": "self-harm";
+    harassment: "harassment";
+    hate: "hate";
+    illicit: "illicit";
+    "child-exploitation": "child-exploitation";
+}> & zod.z.core.$partial, zod.ZodObject<{
+    category: zod.ZodEnum<{
+        sexual: "sexual";
+        violence: "violence";
+        gore: "gore";
+        "self-harm": "self-harm";
+        harassment: "harassment";
+        hate: "hate";
+        illicit: "illicit";
+        "child-exploitation": "child-exploitation";
+    }>;
+    likelihood: zod.ZodEnum<{
+        VERY_UNLIKELY: "VERY_UNLIKELY";
+        UNLIKELY: "UNLIKELY";
+        POSSIBLE: "POSSIBLE";
+        LIKELY: "LIKELY";
+        VERY_LIKELY: "VERY_LIKELY";
+    }>;
+    score: zod.ZodNumber;
+}, zod.z.core.$strip>>;
+export type ClassificationCategories = zod.infer<typeof CATEGORIES_SCHEMA>;
+export declare const CLASSIFICATION_LABEL_SCHEMA: zod.ZodObject<{
+    description: zod.ZodPipe<zod.ZodString, zod.ZodTransform<string, string>>;
+    score: zod.ZodNumber;
+    topicalityScore: zod.ZodOptional<zod.ZodNullable<zod.ZodNumber>>;
+    likelihood: zod.ZodEnum<{
+        VERY_UNLIKELY: "VERY_UNLIKELY";
+        UNLIKELY: "UNLIKELY";
+        POSSIBLE: "POSSIBLE";
+        LIKELY: "LIKELY";
+        VERY_LIKELY: "VERY_LIKELY";
+    }>;
+    knowledgeBaseId: zod.ZodOptional<zod.ZodNullable<zod.ZodPipe<zod.ZodString, zod.ZodTransform<string, string>>>>;
+}, zod.z.core.$strip>;
+export type ClassificationLabel = zod.infer<typeof CLASSIFICATION_LABEL_SCHEMA>;
+export declare const CLASSIFICATION_REPORT_SCHEMA: zod.ZodObject<{
+    processedAt: zod.ZodNumber;
+    categories: zod.ZodRecord<zod.ZodEnum<{
+        sexual: "sexual";
+        violence: "violence";
+        gore: "gore";
+        "self-harm": "self-harm";
+        harassment: "harassment";
+        hate: "hate";
+        illicit: "illicit";
+        "child-exploitation": "child-exploitation";
+    }> & zod.z.core.$partial, zod.ZodObject<{
+        category: zod.ZodEnum<{
+            sexual: "sexual";
+            violence: "violence";
+            gore: "gore";
+            "self-harm": "self-harm";
+            harassment: "harassment";
+            hate: "hate";
+            illicit: "illicit";
+            "child-exploitation": "child-exploitation";
+        }>;
+        likelihood: zod.ZodEnum<{
+            VERY_UNLIKELY: "VERY_UNLIKELY";
+            UNLIKELY: "UNLIKELY";
+            POSSIBLE: "POSSIBLE";
+            LIKELY: "LIKELY";
+            VERY_LIKELY: "VERY_LIKELY";
+        }>;
+        score: zod.ZodNumber;
+    }, zod.z.core.$strip>>;
+    flagged: zod.ZodBoolean;
+    score: zod.ZodNumber;
+    notes: zod.ZodOptional<zod.ZodNullable<zod.ZodPipe<zod.ZodString, zod.ZodTransform<string, string>>>>;
+    labels: zod.ZodOptional<zod.ZodNullable<zod.ZodArray<zod.ZodObject<{
+        description: zod.ZodPipe<zod.ZodString, zod.ZodTransform<string, string>>;
+        score: zod.ZodNumber;
+        topicalityScore: zod.ZodOptional<zod.ZodNullable<zod.ZodNumber>>;
+        likelihood: zod.ZodEnum<{
+            VERY_UNLIKELY: "VERY_UNLIKELY";
+            UNLIKELY: "UNLIKELY";
+            POSSIBLE: "POSSIBLE";
+            LIKELY: "LIKELY";
+            VERY_LIKELY: "VERY_LIKELY";
+        }>;
+        knowledgeBaseId: zod.ZodOptional<zod.ZodNullable<zod.ZodPipe<zod.ZodString, zod.ZodTransform<string, string>>>>;
+    }, zod.z.core.$strip>>>>;
+}, zod.z.core.$strip>;
+export type ClassificationReport = zod.infer<typeof CLASSIFICATION_REPORT_SCHEMA>;

package/esm/Classification.js

@@ -0,0 +1,113 @@
+import * as zod from "zod/v4";
+import { saneStringField } from "./SchemaUtils";
+// OpenAI Content Moderation Categories (Merged subcategories)
+export const CLASSIFICATION_CATEGORIES = [
+    "sexual",
+    "violence",
+    "gore",
+    "self-harm",
+    "harassment",
+    "hate",
+    "illicit",
+    "child-exploitation",
+];
+export const CLASSIFICATION_CATEGORY_SCHEMA = zod.enum(CLASSIFICATION_CATEGORIES);
+// Type to define category information including whether it's text-only
+export const CLASSIFICATION_CATEGORY_INFO_SCHEMA = zod.object({
+    category: CLASSIFICATION_CATEGORY_SCHEMA,
+    displayName: saneStringField(),
+    description: saneStringField(),
+    textOnly: zod.boolean(),
+    supportsImages: zod.boolean(),
+});
+// Category information mapping
+export const CLASSIFICATION_CATEGORY_INFO = {
+    sexual: {
+        category: "sexual",
+        displayName: "Sexual Content",
+        description: "Content meant to arouse sexual excitement, such as the description of sexual activity, or that promotes sexual services.",
+        textOnly: false,
+        supportsImages: true,
+    },
+    violence: {
+        category: "violence",
+        displayName: "Violence",
+        description: "Content that depicts death, violence, or physical injury.",
+        textOnly: false,
+        supportsImages: true,
+    },
+    gore: {
+        category: "gore",
+        displayName: "Gore",
+        description: "Content that depicts death, violence, or physical injury in graphic, explicit detail.",
+        textOnly: false,
+        supportsImages: true,
+    },
+    "self-harm": {
+        category: "self-harm",
+        displayName: "Self-Harm",
+        description: "Content that promotes, encourages, or depicts acts of self-harm, including intent and instructions for self-harm activities.",
+        textOnly: false,
+        supportsImages: true,
+    },
+    harassment: {
+        category: "harassment",
+        displayName: "Harassment",
+        description: "Content that expresses, incites, or promotes harassing language towards any target, including threatening harassment.",
+        textOnly: true,
+        supportsImages: false,
+    },
+    hate: {
+        category: "hate",
+        displayName: "Hate Speech",
+        description: "Content that expresses, incites, or promotes hate based on race, gender, ethnicity, religion, nationality, sexual orientation, disability status, or caste, including threatening hate speech.",
+        textOnly: true,
+        supportsImages: false,
+    },
+    illicit: {
+        category: "illicit",
+        displayName: "Illicit Content",
+        description: "Content that gives advice or instruction on how to commit illicit acts, including violent illegal activities.",
+        textOnly: true,
+        supportsImages: false,
+    },
+    "child-exploitation": {
+        category: "child-exploitation",
+        displayName: "Child Exploitation",
+        description: "Content that sexualizes, grooms, abuses, or otherwise exploits children under 18 years old.",
+        textOnly: true,
+        supportsImages: false,
+    },
+};
+// Helper function to get category info
+export const getCategoryInfo = (category) => {
+    return CLASSIFICATION_CATEGORY_INFO[category];
+};
+export const LIKELIHOOD_SCHEMA = zod.enum([
+    "VERY_UNLIKELY",
+    "UNLIKELY",
+    "POSSIBLE",
+    "LIKELY",
+    "VERY_LIKELY",
+]);
+export const CLASSIFICATION_CATEGORY_REPORT_SCHEMA = zod.object({
+    category: CLASSIFICATION_CATEGORY_SCHEMA,
+    likelihood: LIKELIHOOD_SCHEMA,
+    score: zod.number(),
+});
+export const CATEGORIES_SCHEMA = zod.partialRecord(CLASSIFICATION_CATEGORY_SCHEMA, CLASSIFICATION_CATEGORY_REPORT_SCHEMA);
+export const CLASSIFICATION_LABEL_SCHEMA = zod.object({
+    description: saneStringField(),
+    score: zod.number(),
+    topicalityScore: zod.number().nullish(),
+    likelihood: LIKELIHOOD_SCHEMA,
+    knowledgeBaseId: saneStringField().nullish(),
+});
+export const CLASSIFICATION_REPORT_SCHEMA = zod.object({
+    processedAt: zod.number(),
+    categories: CATEGORIES_SCHEMA,
+    flagged: zod.boolean(),
+    score: zod.number(),
+    notes: saneStringField().nullish(),
+    labels: zod.array(CLASSIFICATION_LABEL_SCHEMA).nullish(),
+});

package/esm/SchemaUtils.d.ts

@@ -0,0 +1,11 @@
+import * as zod from "zod/v4";
+export declare const primaryUuidField: () => zod.ZodString;
+export declare const uuidField: () => zod.ZodString;
+export declare const createdAtField: () => zod.ZodNumber;
+export declare const updatedAtField: () => zod.ZodOptional<zod.ZodNumber>;
+export interface SaneStringOptions {
+    type?: "small" | "medium" | "large";
+    minWidth?: number;
+}
+export declare const saneStringField: (options?: SaneStringOptions) => zod.ZodPipe<zod.ZodString, zod.ZodTransform<string, string>>;
+export declare const urlField: () => zod.ZodPipe<zod.ZodString, zod.ZodTransform<string, string>>;

package/esm/SchemaUtils.js

@@ -0,0 +1,46 @@
+import * as zod from "zod/v4";
+import { meta, primaryKey, updatedAt } from "zodbase";
+import { validateUrl } from "./ValidationUtils";
+export const primaryUuidField = () => zod
+    .string()
+    .uuid({
+    version: "v4",
+})
+    .meta(meta([primaryKey()]));
+export const uuidField = () => zod.string().uuid({
+    version: "v4",
+});
+export const createdAtField = () => zod.number().int();
+export const updatedAtField = () => zod
+    .number()
+    .int()
+    .optional()
+    .meta(meta([updatedAt()]));
+const SIZE_LIMITS = {
+    small: 64,
+    medium: 200,
+    large: 1500,
+};
+export const saneStringField = (options) => {
+    return zod
+        .string()
+        .transform((value) => value.trim())
+        .refine((value) => {
+        if ((options === null || options === void 0 ? void 0 : options.minWidth) && value.length < options.minWidth) {
+            return false;
+        }
+        return true;
+    }, "Not long enough")
+        .refine((value) => {
+        var _a;
+        const sizeLimit = SIZE_LIMITS[(_a = options === null || options === void 0 ? void 0 : options.type) !== null && _a !== void 0 ? _a : "medium"];
+        return typeof value === "string" && value.length < sizeLimit;
+    }, "Too long");
+};
+export const urlField = () => saneStringField().refine((value) => {
+    /*if (encodeURI(value) !== value) {
+      return false;
+    }*/
+    const parsedUrl = validateUrl(value);
+    return Boolean(parsedUrl);
+}, "Invalid link");

package/esm/SharedTypes.d.ts

@@ -0,0 +1,13 @@
+import type { AssetVisibility } from "./Asset";
+export type SubmitAssetOptions = ({
+    file: string;
+    fileType: string;
+    url?: string;
+} | {
+    url: string;
+}) & {
+    name: string;
+    description?: string;
+    keepAfterProcessing?: boolean;
+    visibility?: AssetVisibility;
+};

package/esm/SharedTypes.js

@@ -0,0 +1 @@
+export {};

package/esm/ValidationUtils.d.ts

@@ -0,0 +1 @@
+export declare const validateUrl: (url: string) => URL | undefined;

package/esm/ValidationUtils.js

@@ -0,0 +1,29 @@
+const VALID_PREFIXES = ["http://", "https://", "mailto:", "tel:", "sms:"];
+const EMAIL_REGEX = /^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/;
+const PHONE_REGEX = /^\+?[0-9]+$/;
+export const validateUrl = (url) => {
+    if (!url) {
+        return undefined;
+    }
+    let parsedUrl = url;
+    if (!VALID_PREFIXES.some((prefix) => parsedUrl.startsWith(prefix))) {
+        if (EMAIL_REGEX.test(parsedUrl)) {
+            parsedUrl = `mailto:${parsedUrl}`;
+        }
+        else if (PHONE_REGEX.test(parsedUrl)) {
+            parsedUrl = `tel:${parsedUrl}`;
+        }
+        else {
+            parsedUrl = `https://${parsedUrl}`;
+        }
+    }
+    try {
+        const url = new URL(parsedUrl);
+        if (url.protocol.includes("http") && !url.host.includes(".")) {
+            return undefined;
+        }
+        return url;
+    }
+    catch (error) { }
+    return undefined;
+};

package/esm/index.d.ts

@@ -0,0 +1,3 @@
+export { default as CalmLensClient } from "./CalmLensClient";
+export type { CalmLensClientOptions } from "./CalmLensTypes";
+export { verifyWebhookSignature } from "./CalmLensUtils";

package/esm/index.js

@@ -0,0 +1,3 @@
+/// <reference types="typescript" />
+export { default as CalmLensClient } from "./CalmLensClient";
+export { verifyWebhookSignature } from "./CalmLensUtils";

package/package.json

@@ -0,0 +1,71 @@
+{
+  "name": "@calmlens/js-sdk",
+  "version": "0.0.0",
+  "main": "cjs/index.js",
+  "types": "esm/index.d.ts",
+  "module": "esm/index.js",
+  "sideEffects": false,
+  "scripts": {
+    "generate:fixtures": "bun scripts/generateFixtures.ts",
+    "prepublishOnly": "npm run check:fix && npm run test && npm run build",
+    "test": "echo 'Tests pass'",
+    "example:start": "cd example && npm run start",
+    "check:fix": "tsc --noEmit --project tsconfig.json && npx @biomejs/biome check --write",
+    "check": "tsc --noEmit --project tsconfig.json && npx @biomejs/biome check",
+    "cleanup": "rimraf esm && rimraf cjs",
+    "build": "npm run cleanup && npm run build:esm && npm run build:cjs",
+    "build:esm": "tsc --module es2015 --target es2016 --outDir esm --preserveWatchOutput && rm -rf esm/tests && node scripts/post-build.js esm",
+    "build:cjs": "tsc --module commonjs --target es5 --outDir cjs --preserveWatchOutput && rm -rf cjs/tests && node scripts/post-build.js cjs",
+    "website:dev": "cd website && npm run start",
+    "website:deploy": "cd website && npm run deploy"
+  },
+  "keywords": [
+    "typescript",
+    "javascript",
+    "node",
+    "web",
+    "api",
+    "typed",
+    "cache",
+    "fetch",
+    "retry",
+    "middleware"
+  ],
+  "files": [
+    "LICENSE",
+    "README.md",
+    "esm/",
+    "cjs/",
+    "bin/"
+  ],
+  "jest": {
+    "transform": {
+      "^.+\\.(t|j)sx?$": [
+        "@swc/jest",
+        {
+          "env": {}
+        }
+      ]
+    }
+  },
+  "devDependencies": {
+    "@biomejs/biome": "^2.2.5",
+    "@swc/core": "^1.13.5",
+    "@swc/jest": "^0.2.39",
+    "@types/bun": "^1.2.22",
+    "@types/jest": "^30.0.0",
+    "@types/lodash": "^4.17.20",
+    "@types/node": "24.6.2",
+    "chalk": "4.1.2",
+    "cross-env": "10.1.0",
+    "esbuild": "^0.25.10",
+    "jest": "30.2.0",
+    "npm-run-all": "4.1.5",
+    "rimraf": "6.0.1",
+    "typescript": "^5.9.3",
+    "zod": "4.1.3"
+  },
+  "dependencies": {
+    "api-def": "^0.12.0-alpha.55"
+  }
+}