@upstart.gg/sdk 0.0.135 → 0.0.137

package/src/shared/bricks/props/align.ts

@@ -1,6 +1,5 @@
 import type { Static, StringOptions } from "@sinclair/typebox";
 import { StringEnum } from "~/shared/utils/string-enum";
-import { typedRef } from "~/shared/utils/typed-ref";
 
 export function justifyContent(options: StringOptions = {}) {
   return StringEnum(
@@ -20,10 +19,6 @@ export function justifyContent(options: StringOptions = {}) {
 
 export type JustifyContentSettings = Static<ReturnType<typeof justifyContent>>;
 
-export function justifyContentRef(options: StringOptions = {}) {
-  return typedRef("styles:justifyContent", options);
-}
-
 export function alignItems(options: StringOptions = {}) {
   return StringEnum(["items-start", "items-center", "items-end", "items-stretch"], {
     enumNames: ["Start", "Center", "End", "Stretch"],
@@ -39,10 +34,6 @@ export function alignItems(options: StringOptions = {}) {
 
 export type AlignItemsSettings = Static<ReturnType<typeof alignItems>>;
 
-export function alignItemsRef(options: StringOptions = {}) {
-  return typedRef("styles:alignItems", options);
-}
-
 export function alignSelf(options: StringOptions = {}) {
   return StringEnum(["self-auto", "self-start", "self-center", "self-end", "self-stretch"], {
     enumNames: ["Auto", "Start", "Center", "End", "Stretch"],
@@ -57,7 +48,3 @@ export function alignSelf(options: StringOptions = {}) {
 }
 
 export type AlignSelfSettings = Static<ReturnType<typeof alignSelf>>;
-
-export function alignSelfRef(options: StringOptions = {}) {
-  return typedRef("styles:alignSelf", options);
-}

package/src/shared/bricks/props/background.ts

@@ -1,7 +1,6 @@
 import { type SchemaOptions, Type, type Static } from "@sinclair/typebox";
 import type { ElementColorType } from "~/shared/themes/color-system";
 import { StringEnum } from "~/shared/utils/string-enum";
-import { typedRef } from "~/shared/utils/typed-ref";
 
 type BackgroundOptions = {
   title?: string;
@@ -14,7 +13,6 @@ type BackgroundOptions = {
 };
 
 export function background(opts: BackgroundOptions = {}) {
-  const { default: defValue, ...restOpts } = opts;
   return Type.Object(
     {
       image: Type.String({
@@ -26,14 +24,12 @@ export function background(opts: BackgroundOptions = {}) {
       size: Type.Optional(
         StringEnum(["auto", "cover", "contain"], {
           enumNames: ["Auto", "Cover", "Contain"],
-          default: defValue?.size ?? "auto",
           "ai:instructions": "Only use this when the image is set.",
         }),
       ),
       repeat: Type.Optional(
         StringEnum(["no-repeat", "repeat", "repeat-x", "repeat-y", "space", "round"], {
           enumNames: ["No repeat", "Repeat", "Repeat horizontally", "Repeat vertically", "Space", "Round"],
-          default: defValue?.repeat ?? "no-repeat",
           "ai:instructions": "Only use this when the image is set.",
         }),
       ),
@@ -45,18 +41,13 @@ export function background(opts: BackgroundOptions = {}) {
       title: "Background image",
       // disable for now
       // "ui:show-img-search": true,
-      default: defValue,
-      ...restOpts,
+      ...opts,
     },
   );
 }
 
 export type BackgroundSettings = Static<ReturnType<typeof background>>;
 
-export function backgroundRef(options: SchemaOptions = {}) {
-  return typedRef("styles:background", options);
-}
-
 export function backgroundColor(options: SchemaOptions = {}) {
   return Type.String({
     title: "Background color",
@@ -73,7 +64,3 @@ export function backgroundColor(options: SchemaOptions = {}) {
 }
 
 export type BackgroundColorSettings = Static<ReturnType<typeof backgroundColor>>;
-
-export function backgroundColorRef(options: SchemaOptions = {}) {
-  return typedRef("styles:backgroundColor", options);
-}

package/src/shared/bricks/props/border.ts

@@ -1,7 +1,6 @@
 import { type ObjectOptions, Type, type Static, type StringOptions } from "@sinclair/typebox";
-import { typedRef } from "~/shared/utils/typed-ref";
 import { StringEnum } from "~/shared/utils/string-enum";
-import { borderColorRef } from "./color";
+import { borderColor } from "./color";
 
 export function border(opts: ObjectOptions = {}) {
   return Type.Object(
@@ -15,7 +14,7 @@ export function border(opts: ObjectOptions = {}) {
         "ui:placeholder": "None",
         default: "border-0",
       }),
-      color: borderColorRef({
+      color: borderColor({
         title: "Color",
         description: "The color of the border.",
         default: "border-current",
@@ -48,12 +47,6 @@ export function border(opts: ObjectOptions = {}) {
 
 export type BorderSettings = Static<ReturnType<typeof border>>;
 
-export function borderRef(
-  options: Omit<ObjectOptions, "default"> & { default?: Partial<BorderSettings> } = {},
-) {
-  return typedRef("styles:border", options);
-}
-
 export function rounding(opts: StringOptions = {}) {
   return Type.Optional(
     StringEnum(
@@ -80,7 +73,3 @@ export function rounding(opts: StringOptions = {}) {
 }
 
 export type RoundingSettings = Static<ReturnType<typeof rounding>>;
-
-export function roundingRef(options: StringOptions = {}) {
-  return typedRef("styles:rounding", options);
-}

package/src/shared/bricks/props/color-preset.ts

@@ -1,13 +1,12 @@
 import { type Static, type ObjectOptions, Type, type StringOptions, TObject } from "@sinclair/typebox";
 import { StringEnum } from "~/shared/utils/string-enum";
-import { typedRef } from "~/shared/utils/typed-ref";
 
 type ColorPresetOptions = ObjectOptions & {
   "ui:presets"?: Record<string, { className: string; label: string }>;
   "ui:default-gradient-direction"?: string;
 };
 
-export const colorPresets: NonNullable<ColorPresetOptions["ui:presets"]> = {
+export const colorPresets = {
   "primary-50": {
     className: "bg-primary-50 text-primary-50-content",
     label: "Primary 50",
@@ -320,21 +319,25 @@ export const colorPresets: NonNullable<ColorPresetOptions["ui:presets"]> = {
     className: "",
     label: "None",
   },
-};
+} as const;
+
+export type ColorPreset = keyof typeof colorPresets;
 
 export function colorPreset(options: ColorPresetOptions = {}) {
   return Type.Object(
     {
-      color: StringEnum(Object.keys(colorPresets), {
+      color: StringEnum(Object.keys(colorPresets) as Array<ColorPreset>, {
         title: "Color preset",
         description: "Color preset to apply to background and text",
-        enumNames: Object.keys(colorPresets).map((key) => colorPresets[key].label),
+        enumNames: Object.keys(colorPresets).map(
+          (key) => colorPresets[key as keyof typeof colorPresets].label,
+        ),
         "ai:instructions": `Presets are predefined color combinations of background and text colors that can be applied to elements.
 The possible semantic colors are primary, secondary, accent, neutral, and base, each declined in various shades from 50 to 900. (except base which has only 100, 200, and 300).
 You can use gradients using color gradient variations (e.g. primary-gradient-100, secondary-gradient-200, etc.). In this case, you will also need to set the gradient direction.`,
         "ui:styleId": "presets:color",
         "ui:responsive": true,
-        default: options.default?.color,
+        default: options.default?.color ?? "none",
       }),
       gradientDirection: Type.Optional(gradientDirection(options)),
     },
@@ -356,10 +359,6 @@ You can use gradients using color gradient variations (e.g. primary-gradient-100
 
 export type ColorPresetSettings = Static<ReturnType<typeof colorPreset>>;
 
-export function colorPresetRef(options: ColorPresetOptions = {}) {
-  return typedRef("presets:color", options);
-}
-
 function gradientDirection(options: StringOptions = {}) {
   return StringEnum(
     [

package/src/shared/bricks/props/color.ts

@@ -1,40 +1,29 @@
-import { type SchemaOptions, type Static, type StringOptions, type TObject, Type } from "@sinclair/typebox";
-import { typedRef } from "~/shared/utils/typed-ref";
+import { type Static, type StringOptions, Type } from "@sinclair/typebox";
 
-export function color(defaultValue?: string, title = "Text color") {
+export function color(options: StringOptions = {}) {
   return Type.String({
-    title,
-    // $id: "styles:color",
+    title: "Text color",
     "ai:instructions":
       "hex/rgb/rgba color or classes like `text-<variant>-<shade>`, variants being `primary`, `secondary`, `accent` and `neutral`, and shades between 50 and 900",
-    default: defaultValue,
     "ui:styleId": "styles:color",
     "ui:field": "color",
     "ui:color-type": "text",
+    ...options,
   });
 }
 
 export type ColorSettings = Static<ReturnType<typeof color>>;
 
-export function colorRef(options: SchemaOptions = {}) {
-  return typedRef("styles:color", { ...options, "ui:styleId": "styles:color" });
-}
-
-export function borderColor(defaultValue?: string, title = "Border color") {
+export function borderColor(options: StringOptions = {}) {
   return Type.String({
-    title,
-    // $id: "styles:borderColor",
+    title: "Border color",
     "ai:instructions":
       "hex/rgb/rgba color or classes like `border-<variant>-<shade>`, variants being `primary`, `secondary`, `accent` and `neutral`, and shades between 50 and 900",
-    default: defaultValue,
     "ui:styleId": "styles:borderColor",
     "ui:field": "color",
     "ui:color-type": "border",
+    ...options,
   });
 }
 
 export type BorderColorSettings = Static<ReturnType<typeof borderColor>>;
-
-export function borderColorRef(options: SchemaOptions = {}) {
-  return typedRef("styles:borderColor", { ...options, "ui:styleId": "styles:borderColor" });
-}

package/src/shared/bricks/props/common.ts

@@ -1,7 +1,6 @@
 import { type Static, type TString, Type } from "@sinclair/typebox";
-import { typedRef } from "~/shared/utils/typed-ref";
-import { cssLengthRef } from "./css-length";
-import { alignSelfRef } from "./align";
+import { cssLength } from "./css-length";
+import { alignSelf } from "./align";
 
 export function hidden() {
   return Type.Object(
@@ -25,7 +24,7 @@ export const commonProps = {
       "ai:hidden": true,
     }),
   ),
-  hidden: Type.Optional(typedRef("styles:hidden")),
+  hidden: Type.Optional(hidden()),
   editable: Type.Optional(
     Type.Boolean({
       "ui:field": "hidden",
@@ -33,7 +32,7 @@ export const commonProps = {
     }),
   ),
   width: Type.Optional(
-    cssLengthRef({
+    cssLength({
       title: "Fixed Width",
       description:
         "Set a fixed width for the brick. If not set, the brick will be responsive and will follow the flex layout of its parent section.",
@@ -42,7 +41,7 @@ export const commonProps = {
     }) as TString,
   ),
   height: Type.Optional(
-    cssLengthRef({
+    cssLength({
       title: "Fixed height",
       description:
         "Set a fixed height for the brick. If not set, the brick will be responsive and will follow the flex layout of its parent section.",
@@ -57,7 +56,7 @@ export const commonProps = {
       "ui:responsive": true,
     }),
   ),
-  alignSelf: Type.Optional(alignSelfRef()),
+  alignSelf: Type.Optional(alignSelf()),
 };
 
 const commonPropsSchema = Type.Object(commonProps);

package/src/shared/bricks/props/css-length.ts

@@ -1,5 +1,4 @@
 import { type Static, Type, type StringOptions } from "@sinclair/typebox";
-import { typedRef } from "~/shared/utils/typed-ref";
 
 export const cssUnits = ["px", "%", "em", "rem", "vh", "vw", "dvh", "dvw", "rlh", "lh", "cqh", "cqw"];
 
@@ -18,10 +17,6 @@ export function cssLength(options: StringOptions = {}) {
 
 export type CssLength = Static<ReturnType<typeof cssLength>>;
 
-export function cssLengthRef(options: StringOptions = {}) {
-  return typedRef("styles:cssLength", options);
-}
-
 export function isCssLength(value: string | number | undefined): boolean {
   if (typeof value !== "string") {
     return false;

package/src/shared/bricks/props/datasource.ts

@@ -1,82 +1,80 @@
 import { Type, type Static } from "@sinclair/typebox";
 import { StringEnum } from "~/shared/utils/string-enum";
 
-export function datasource(title = "Database") {
-  return Type.Object(
-    {
-      id: Type.String({
-        title: "Database",
+export const deprecated_datasourceField = Type.Object(
+  {
+    id: Type.String({
+      title: "Database",
+    }),
+    offset: Type.Optional(
+      Type.Number({
+        title: "Offset",
+        description: "Offset the records to fetch from the datasource",
+        minimum: 0,
+        default: 0,
       }),
-      offset: Type.Optional(
-        Type.Number({
-          title: "Offset",
-          description: "Offset the records to fetch from the datasource",
-          minimum: 0,
-          default: 0,
-        }),
-      ),
-      limit: Type.Optional(
-        Type.Number({
-          title: "Limit",
-          description:
-            "Limit the number of records to fetch from the datasource. Setting to 1 will fetch and render only one item.",
-          minimum: 1,
-          default: 3,
-        }),
-      ),
-      sortDirection: Type.Optional(
-        StringEnum(["asc", "desc"], {
-          title: "Sort",
-          enumNames: ["Ascending", "Descending"],
-          description: "Direction to sort the records by",
-          default: "desc",
-        }),
-      ),
-      sortField: Type.Optional(
-        Type.String({
-          title: "Sort Field",
-          description: "Select a field to sort by (must be indexed)",
-          default: "$publicationDate",
+    ),
+    limit: Type.Optional(
+      Type.Number({
+        title: "Limit",
+        description:
+          "Limit the number of records to fetch from the datasource. Setting to 1 will fetch and render only one item.",
+        minimum: 1,
+        default: 3,
+      }),
+    ),
+    sortDirection: Type.Optional(
+      StringEnum(["asc", "desc"], {
+        title: "Sort",
+        enumNames: ["Ascending", "Descending"],
+        description: "Direction to sort the records by",
+        default: "desc",
+      }),
+    ),
+    sortField: Type.Optional(
+      Type.String({
+        title: "Sort Field",
+        description: "Select a field to sort by (must be indexed)",
+        default: "$publicationDate",
+      }),
+    ),
+    filters: Type.Optional(
+      Type.Array(
+        Type.Object({
+          field: Type.String(),
+          op: StringEnum([
+            "eq",
+            "ne",
+            "lt",
+            "lte",
+            "gt",
+            "gte",
+            "in",
+            "nin",
+            "contains",
+            "notContains",
+            "startsWith",
+            "notStartsWith",
+            "endsWith",
+            "notEndsWith",
+            "before",
+            "after",
+          ]),
+          value: Type.Union([Type.String(), Type.Number(), Type.Boolean()]),
         }),
+        {
+          default: [],
+        },
       ),
-      filters: Type.Optional(
-        Type.Array(
-          Type.Object({
-            field: Type.String(),
-            op: StringEnum([
-              "eq",
-              "ne",
-              "lt",
-              "lte",
-              "gt",
-              "gte",
-              "in",
-              "nin",
-              "contains",
-              "notContains",
-              "startsWith",
-              "notStartsWith",
-              "endsWith",
-              "notEndsWith",
-              "before",
-              "after",
-            ]),
-            value: Type.Union([Type.String(), Type.Number(), Type.Boolean()]),
-          }),
-          {
-            default: [],
-          },
-        ),
-      ),
-    },
-    {
-      "ui:field": "datasource",
-      title,
-      metadata: {
-        category: "content",
-      },
+    ),
+  },
+  {
+    "ui:field": "datasource",
+    title: "Database",
+    metadata: {
+      category: "content",
     },
-  );
-}
+  },
+);
 
-export type DatasourceSettings = Static<ReturnType<typeof datasource>>;
+export type DeprecatedDatasourceSettings = Static<typeof deprecated_datasourceField>;

package/src/shared/bricks/props/direction.ts

@@ -1,12 +1,12 @@
 import { type SchemaOptions, type Static, type StringOptions, Type } from "@sinclair/typebox";
 import { StringEnum } from "~/shared/utils/string-enum";
-import { typedRef } from "~/shared/utils/typed-ref";
 
 export function direction(options: StringOptions = {}) {
   return StringEnum(["flex-row", "flex-col"], {
     title: "Direction",
     description: "The direction of the layout",
     enumNames: ["Horizontal", "Vertical"],
+    default: "flex-row",
     // $id: "styles:direction",
     "ui:styleId": "styles:direction",
     examples: ["flex-row", "flex-col"],
@@ -15,7 +15,3 @@ export function direction(options: StringOptions = {}) {
 }
 
 export type DirectionSettings = Static<ReturnType<typeof direction>>;
-
-export function directionRef(options: SchemaOptions = {}) {
-  return typedRef("styles:direction", options);
-}

package/src/shared/bricks/props/dynamic.ts

@@ -1,4 +1,3 @@
-import { typedRef } from "~/shared/utils/typed-ref";
 import { type ObjectOptions, Type, type Static } from "@sinclair/typebox";
 import { queryFilter } from "~/shared/datasources/types";
 
@@ -53,14 +52,8 @@ export function queryUse() {
   );
 }
 
-export const queryUseSchema = queryUseRef();
-
 export type QueryUseSettings = Static<ReturnType<typeof queryUse>>;
 
-export function queryUseRef(options: ObjectOptions = {}) {
-  return typedRef("content:queryUse", options);
-}
-
 export function loop(options: ObjectOptions = {}) {
   return Type.Object(
     {
@@ -105,7 +98,3 @@ export function loop(options: ObjectOptions = {}) {
 }
 
 export type LoopSettings = Static<ReturnType<typeof loop>>;
-
-export function loopRef(options: ObjectOptions = {}) {
-  return typedRef("content:loop", options);
-}

package/src/shared/bricks/props/effects.ts

@@ -1,5 +1,4 @@
 import { type SchemaOptions, Type, type Static } from "@sinclair/typebox";
-import { typedRef } from "~/shared/utils/typed-ref";
 import { StringEnum, type StringEnumOptions } from "~/shared/utils/string-enum";
 
 export function shadow(options: StringEnumOptions = {}) {
@@ -19,10 +18,6 @@ export function shadow(options: StringEnumOptions = {}) {
 
 export type ShadowSettings = Static<ReturnType<typeof shadow>>;
 
-export function shadowRef(options: StringEnumOptions = {}) {
-  return typedRef("styles:shadow", options);
-}
-
 /**
  * This function is used in ajv and type ref translations, but should not be used directly in bricks
  */
@@ -43,10 +38,6 @@ export function textShadow(options: StringEnumOptions = {}) {
   );
 }
 
-export function textShadowRef(options: SchemaOptions = {}) {
-  return typedRef("styles:textShadow", options);
-}
-
 export type TextShadowSettings = Static<ReturnType<typeof textShadow>>;
 
 type OpacityOptions = {

package/src/shared/bricks/props/geolocation.ts

@@ -1,6 +1,5 @@
 import { type ObjectOptions, Type, type Static } from "@sinclair/typebox";
 import { number } from "./number";
-import { string } from "./string";
 
 export function geolocation(opts: ObjectOptions & { defaultZoom?: number } = {}) {
   const { title = "Location", defaultZoom } = opts;
@@ -8,10 +7,11 @@ export function geolocation(opts: ObjectOptions & { defaultZoom?: number } = {})
     {
       lat: number("Latitude", { "ui:field": "hidden" }),
       lng: number("Longitude", { "ui:field": "hidden" }),
-      address: string("Address", {
+      address: Type.String({
+        title: "Address",
         "ui:field": "geoaddress",
       }),
-      tooltip: Type.Optional(string("Tooltip", {})),
+      tooltip: Type.Optional(Type.String({ title: "Tooltip" })),
       zoom: Type.Optional(
         number("Zoom", {
           description: "Zoom level for the map",

package/src/shared/bricks/props/helpers.ts

@@ -66,7 +66,7 @@ export function defineProps<P extends TProperties>(
     ...(options?.noAlignSelf ? {} : { alignSelf }),
     ...(options?.noGrow ? {} : { grow }),
   } as typeof allProps;
-  return Type.Object(finalProps, { ...options, additionalProperties: false });
+  return Type.Object(finalProps, options);
 }
 
 // export const optional = Type.Optional;

package/src/shared/bricks/props/image.ts

@@ -1,6 +1,5 @@
-import { type SchemaOptions, Type, type Static, type ObjectOptions } from "@sinclair/typebox";
+import { Type, type Static, type ObjectOptions } from "@sinclair/typebox";
 import { StringEnum } from "~/shared/utils/string-enum";
-import { typedRef } from "~/shared/utils/typed-ref";
 
 type PropImageOptions = {
   defaultImageUrl?: string;
@@ -8,13 +7,12 @@ type PropImageOptions = {
   noObjectOptions?: boolean;
 } & ObjectOptions;
 
-export function image(title = "Image", options: PropImageOptions = {}) {
+export function image(options: PropImageOptions = {}) {
   const { defaultImageUrl, showImgSearch = false, noObjectOptions = false } = options;
   const schema = Type.Object(
     {
       src: Type.String({
-        default: defaultImageUrl,
-        title,
+        title: options.title ?? "Image URL",
         description: "Image URL. Can be a link to an image or a data URI",
       }),
       alt: Type.Optional(
@@ -29,7 +27,6 @@ export function image(title = "Image", options: PropImageOptions = {}) {
           enumNames: ["None", "Contain", "Cover", "Fill", "Scale down"],
           title: "Fit",
           description: "How the image should be resized to fit its container",
-          default: "object-cover",
           "ui:field": "enum",
           "ui:styleId": "styles:objectFit",
         }),
@@ -69,16 +66,11 @@ export function image(title = "Image", options: PropImageOptions = {}) {
     },
     {
       // $id: "assets:image",
-      title,
+      title: "Image",
       "ui:field": "image",
       "ui:accept": "image/*",
       "ui:show-img-search": showImgSearch,
       "ui:no-object-options": noObjectOptions,
-      default: {
-        alt: "Image",
-        fit: "object-cover",
-        position: "object-center",
-      },
       // "ui:responsive": "desktop",
       metadata: {
         category: "content",
@@ -89,8 +81,4 @@ export function image(title = "Image", options: PropImageOptions = {}) {
   return schema;
 }
 
-export function imageRef(options: PropImageOptions & SchemaOptions = {}) {
-  return typedRef("assets:image", options);
-}
-
 export type ImageProps = Static<ReturnType<typeof image>>;