cetec-design-system 0.0.2 → 0.0.4

package/styled-system/recipes/link.mjs

@@ -0,0 +1,83 @@
+import { memo, splitProps } from '../helpers.mjs';
+import { createRecipe, mergeRecipes } from './create-recipe.mjs';
+
+const linkFn = /* @__PURE__ */ createRecipe('link', {
+  "family": "body"
+}, [])
+
+const linkVariantMap = {
+  "textStyle": [
+    "display-lg",
+    "display-md",
+    "display-sm",
+    "display-xs",
+    "heading-lg",
+    "heading-md",
+    "heading-sm",
+    "heading-xs",
+    "body-lg",
+    "body-md",
+    "body-sm",
+    "body-xs",
+    "mono-lg",
+    "mono-md",
+    "mono-sm",
+    "mono-xs"
+  ],
+  "family": [
+    "heading",
+    "body",
+    "mono"
+  ],
+  "bold": [
+    "true"
+  ],
+  "italic": [
+    "true"
+  ],
+  "underline": [
+    "true"
+  ],
+  "size": [
+    "12",
+    "14",
+    "16",
+    "20",
+    "24",
+    "32",
+    "40",
+    "48",
+    "64",
+    "72",
+    "80",
+    "96"
+  ],
+  "weight": [
+    "light",
+    "normal",
+    "medium",
+    "bold",
+    "black"
+  ],
+  "_disabled": [
+    "true"
+  ]
+}
+
+const linkVariantKeys = Object.keys(linkVariantMap)
+
+export const link = /* @__PURE__ */ Object.assign(memo(linkFn.recipeFn), {
+  __recipe__: true,
+  __name__: 'link',
+  __getCompoundVariantCss__: linkFn.__getCompoundVariantCss__,
+  raw: (props) => props,
+  variantKeys: linkVariantKeys,
+  variantMap: linkVariantMap,
+  merge(recipe) {
+    return mergeRecipes(this, recipe)
+  },
+  splitVariantProps(props) {
+    return splitProps(props, linkVariantKeys)
+  },
+  getVariantProps: linkFn.getVariantProps,
+})

package/styled-system/recipes/pre.d.ts

@@ -0,0 +1,28 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface PreVariant {
+  
+}
+
+type PreVariantMap = {
+  [key in keyof PreVariant]: Array<PreVariant[key]>
+}
+
+export type PreVariantProps = {
+  [key in keyof PreVariant]?: ConditionalValue<PreVariant[key]> | undefined
+}
+
+export interface PreRecipe {
+  __type: PreVariantProps
+  (props?: PreVariantProps): string
+  raw: (props?: PreVariantProps) => PreVariantProps
+  variantMap: PreVariantMap
+  variantKeys: Array<keyof PreVariant>
+  splitVariantProps<Props extends PreVariantProps>(props: Props): [PreVariantProps, Pretty<DistributiveOmit<Props, keyof PreVariantProps>>]
+  getVariantProps: (props?: PreVariantProps) => PreVariantProps
+}
+
+
+export declare const pre: PreRecipe

package/styled-system/recipes/pre.js

@@ -0,0 +1,24 @@
+import { memo, splitProps } from '../helpers.js';
+import { createRecipe, mergeRecipes } from './create-recipe.js';
+
+const preFn = /* @__PURE__ */ createRecipe('pre', {}, [])
+
+const preVariantMap = {}
+
+const preVariantKeys = Object.keys(preVariantMap)
+
+export const pre = /* @__PURE__ */ Object.assign(memo(preFn.recipeFn), {
+  __recipe__: true,
+  __name__: 'pre',
+  __getCompoundVariantCss__: preFn.__getCompoundVariantCss__,
+  raw: (props) => props,
+  variantKeys: preVariantKeys,
+  variantMap: preVariantMap,
+  merge(recipe) {
+    return mergeRecipes(this, recipe)
+  },
+  splitVariantProps(props) {
+    return splitProps(props, preVariantKeys)
+  },
+  getVariantProps: preFn.getVariantProps,
+})

package/styled-system/recipes/pre.mjs

@@ -0,0 +1,24 @@
+import { memo, splitProps } from '../helpers.mjs';
+import { createRecipe, mergeRecipes } from './create-recipe.mjs';
+
+const preFn = /* @__PURE__ */ createRecipe('pre', {}, [])
+
+const preVariantMap = {}
+
+const preVariantKeys = Object.keys(preVariantMap)
+
+export const pre = /* @__PURE__ */ Object.assign(memo(preFn.recipeFn), {
+  __recipe__: true,
+  __name__: 'pre',
+  __getCompoundVariantCss__: preFn.__getCompoundVariantCss__,
+  raw: (props) => props,
+  variantKeys: preVariantKeys,
+  variantMap: preVariantMap,
+  merge(recipe) {
+    return mergeRecipes(this, recipe)
+  },
+  splitVariantProps(props) {
+    return splitProps(props, preVariantKeys)
+  },
+  getVariantProps: preFn.getVariantProps,
+})

package/styled-system/recipes/radio.d.ts

@@ -0,0 +1,28 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface RadioVariant {
+  
+}
+
+type RadioVariantMap = {
+  [key in keyof RadioVariant]: Array<RadioVariant[key]>
+}
+
+export type RadioVariantProps = {
+  [key in keyof RadioVariant]?: ConditionalValue<RadioVariant[key]> | undefined
+}
+
+export interface RadioRecipe {
+  __type: RadioVariantProps
+  (props?: RadioVariantProps): Pretty<Record<"container" | "input" | "indicator", string>>
+  raw: (props?: RadioVariantProps) => RadioVariantProps
+  variantMap: RadioVariantMap
+  variantKeys: Array<keyof RadioVariant>
+  splitVariantProps<Props extends RadioVariantProps>(props: Props): [RadioVariantProps, Pretty<DistributiveOmit<Props, keyof RadioVariantProps>>]
+  getVariantProps: (props?: RadioVariantProps) => RadioVariantProps
+}
+
+
+export declare const radio: RadioRecipe

package/styled-system/recipes/radio.js

@@ -0,0 +1,40 @@
+import { compact, getSlotCompoundVariant, memo, splitProps } from '../helpers.js';
+import { createRecipe } from './create-recipe.js';
+
+const radioDefaultVariants = {}
+const radioCompoundVariants = []
+
+const radioSlotNames = [
+  [
+    "container",
+    "radio__container"
+  ],
+  [
+    "input",
+    "radio__input"
+  ],
+  [
+    "indicator",
+    "radio__indicator"
+  ]
+]
+const radioSlotFns = /* @__PURE__ */ radioSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, radioDefaultVariants, getSlotCompoundVariant(radioCompoundVariants, slotName))])
+
+const radioFn = memo((props = {}) => {
+  return Object.fromEntries(radioSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]))
+})
+
+const radioVariantKeys = []
+const getVariantProps = (variants) => ({ ...radioDefaultVariants, ...compact(variants) })
+
+export const radio = /* @__PURE__ */ Object.assign(radioFn, {
+  __recipe__: false,
+  __name__: 'radio',
+  raw: (props) => props,
+  variantKeys: radioVariantKeys,
+  variantMap: {},
+  splitVariantProps(props) {
+    return splitProps(props, radioVariantKeys)
+  },
+  getVariantProps
+})

package/styled-system/recipes/radio.mjs

@@ -0,0 +1,40 @@
+import { compact, getSlotCompoundVariant, memo, splitProps } from '../helpers.mjs';
+import { createRecipe } from './create-recipe.mjs';
+
+const radioDefaultVariants = {}
+const radioCompoundVariants = []
+
+const radioSlotNames = [
+  [
+    "container",
+    "radio__container"
+  ],
+  [
+    "input",
+    "radio__input"
+  ],
+  [
+    "indicator",
+    "radio__indicator"
+  ]
+]
+const radioSlotFns = /* @__PURE__ */ radioSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, radioDefaultVariants, getSlotCompoundVariant(radioCompoundVariants, slotName))])
+
+const radioFn = memo((props = {}) => {
+  return Object.fromEntries(radioSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]))
+})
+
+const radioVariantKeys = []
+const getVariantProps = (variants) => ({ ...radioDefaultVariants, ...compact(variants) })
+
+export const radio = /* @__PURE__ */ Object.assign(radioFn, {
+  __recipe__: false,
+  __name__: 'radio',
+  raw: (props) => props,
+  variantKeys: radioVariantKeys,
+  variantMap: {},
+  splitVariantProps(props) {
+    return splitProps(props, radioVariantKeys)
+  },
+  getVariantProps
+})

package/styled-system/recipes/spinner.d.ts

@@ -0,0 +1,31 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface SpinnerVariant {
+  /**
+ * @default "medium"
+ */
+size: "medium" | "small" | "large"
+}
+
+type SpinnerVariantMap = {
+  [key in keyof SpinnerVariant]: Array<SpinnerVariant[key]>
+}
+
+export type SpinnerVariantProps = {
+  [key in keyof SpinnerVariant]?: ConditionalValue<SpinnerVariant[key]> | undefined
+}
+
+export interface SpinnerRecipe {
+  __type: SpinnerVariantProps
+  (props?: SpinnerVariantProps): string
+  raw: (props?: SpinnerVariantProps) => SpinnerVariantProps
+  variantMap: SpinnerVariantMap
+  variantKeys: Array<keyof SpinnerVariant>
+  splitVariantProps<Props extends SpinnerVariantProps>(props: Props): [SpinnerVariantProps, Pretty<DistributiveOmit<Props, keyof SpinnerVariantProps>>]
+  getVariantProps: (props?: SpinnerVariantProps) => SpinnerVariantProps
+}
+
+
+export declare const spinner: SpinnerRecipe

package/styled-system/recipes/spinner.js

@@ -0,0 +1,32 @@
+import { memo, splitProps } from '../helpers.js';
+import { createRecipe, mergeRecipes } from './create-recipe.js';
+
+const spinnerFn = /* @__PURE__ */ createRecipe('spinner', {
+  "size": "medium"
+}, [])
+
+const spinnerVariantMap = {
+  "size": [
+    "medium",
+    "small",
+    "large"
+  ]
+}
+
+const spinnerVariantKeys = Object.keys(spinnerVariantMap)
+
+export const spinner = /* @__PURE__ */ Object.assign(memo(spinnerFn.recipeFn), {
+  __recipe__: true,
+  __name__: 'spinner',
+  __getCompoundVariantCss__: spinnerFn.__getCompoundVariantCss__,
+  raw: (props) => props,
+  variantKeys: spinnerVariantKeys,
+  variantMap: spinnerVariantMap,
+  merge(recipe) {
+    return mergeRecipes(this, recipe)
+  },
+  splitVariantProps(props) {
+    return splitProps(props, spinnerVariantKeys)
+  },
+  getVariantProps: spinnerFn.getVariantProps,
+})

package/styled-system/recipes/spinner.mjs

@@ -0,0 +1,32 @@
+import { memo, splitProps } from '../helpers.mjs';
+import { createRecipe, mergeRecipes } from './create-recipe.mjs';
+
+const spinnerFn = /* @__PURE__ */ createRecipe('spinner', {
+  "size": "medium"
+}, [])
+
+const spinnerVariantMap = {
+  "size": [
+    "medium",
+    "small",
+    "large"
+  ]
+}
+
+const spinnerVariantKeys = Object.keys(spinnerVariantMap)
+
+export const spinner = /* @__PURE__ */ Object.assign(memo(spinnerFn.recipeFn), {
+  __recipe__: true,
+  __name__: 'spinner',
+  __getCompoundVariantCss__: spinnerFn.__getCompoundVariantCss__,
+  raw: (props) => props,
+  variantKeys: spinnerVariantKeys,
+  variantMap: spinnerVariantMap,
+  merge(recipe) {
+    return mergeRecipes(this, recipe)
+  },
+  splitVariantProps(props) {
+    return splitProps(props, spinnerVariantKeys)
+  },
+  getVariantProps: spinnerFn.getVariantProps,
+})

package/styled-system/recipes/switchbox.d.ts

@@ -0,0 +1,28 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface SwitchboxVariant {
+  
+}
+
+type SwitchboxVariantMap = {
+  [key in keyof SwitchboxVariant]: Array<SwitchboxVariant[key]>
+}
+
+export type SwitchboxVariantProps = {
+  [key in keyof SwitchboxVariant]?: ConditionalValue<SwitchboxVariant[key]> | undefined
+}
+
+export interface SwitchboxRecipe {
+  __type: SwitchboxVariantProps
+  (props?: SwitchboxVariantProps): Pretty<Record<"container" | "input" | "indicator", string>>
+  raw: (props?: SwitchboxVariantProps) => SwitchboxVariantProps
+  variantMap: SwitchboxVariantMap
+  variantKeys: Array<keyof SwitchboxVariant>
+  splitVariantProps<Props extends SwitchboxVariantProps>(props: Props): [SwitchboxVariantProps, Pretty<DistributiveOmit<Props, keyof SwitchboxVariantProps>>]
+  getVariantProps: (props?: SwitchboxVariantProps) => SwitchboxVariantProps
+}
+
+
+export declare const switchbox: SwitchboxRecipe

package/styled-system/recipes/switchbox.mjs

@@ -0,0 +1,40 @@
+import { compact, getSlotCompoundVariant, memo, splitProps } from '../helpers.mjs';
+import { createRecipe } from './create-recipe.mjs';
+
+const switchboxDefaultVariants = {}
+const switchboxCompoundVariants = []
+
+const switchboxSlotNames = [
+  [
+    "container",
+    "switchbox__container"
+  ],
+  [
+    "input",
+    "switchbox__input"
+  ],
+  [
+    "indicator",
+    "switchbox__indicator"
+  ]
+]
+const switchboxSlotFns = /* @__PURE__ */ switchboxSlotNames.map(([slotName, slotKey]) => [slotName, createRecipe(slotKey, switchboxDefaultVariants, getSlotCompoundVariant(switchboxCompoundVariants, slotName))])
+
+const switchboxFn = memo((props = {}) => {
+  return Object.fromEntries(switchboxSlotFns.map(([slotName, slotFn]) => [slotName, slotFn.recipeFn(props)]))
+})
+
+const switchboxVariantKeys = []
+const getVariantProps = (variants) => ({ ...switchboxDefaultVariants, ...compact(variants) })
+
+export const switchbox = /* @__PURE__ */ Object.assign(switchboxFn, {
+  __recipe__: false,
+  __name__: 'switchbox',
+  raw: (props) => props,
+  variantKeys: switchboxVariantKeys,
+  variantMap: {},
+  splitVariantProps(props) {
+    return splitProps(props, switchboxVariantKeys)
+  },
+  getVariantProps
+})

package/styled-system/recipes/text.d.ts

@@ -0,0 +1,37 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface TextVariant {
+  /**
+ * @default "body-md"
+ */
+textStyle: "display-lg" | "display-md" | "display-sm" | "display-xs" | "heading-lg" | "heading-md" | "heading-sm" | "heading-xs" | "body-lg" | "body-md" | "body-sm" | "body-xs" | "mono-lg" | "mono-md" | "mono-sm" | "mono-xs"
+family: "heading" | "body" | "mono"
+bold: boolean
+italic: boolean
+underline: boolean
+size: "12" | "14" | "16" | "20" | "24" | "32" | "40" | "48" | "64" | "72" | "80" | "96"
+weight: "light" | "normal" | "medium" | "bold" | "black"
+}
+
+type TextVariantMap = {
+  [key in keyof TextVariant]: Array<TextVariant[key]>
+}
+
+export type TextVariantProps = {
+  [key in keyof TextVariant]?: ConditionalValue<TextVariant[key]> | undefined
+}
+
+export interface TextRecipe {
+  __type: TextVariantProps
+  (props?: TextVariantProps): string
+  raw: (props?: TextVariantProps) => TextVariantProps
+  variantMap: TextVariantMap
+  variantKeys: Array<keyof TextVariant>
+  splitVariantProps<Props extends TextVariantProps>(props: Props): [TextVariantProps, Pretty<DistributiveOmit<Props, keyof TextVariantProps>>]
+  getVariantProps: (props?: TextVariantProps) => TextVariantProps
+}
+
+
+export declare const text: TextRecipe

package/styled-system/recipes/text.js

@@ -0,0 +1,80 @@
+import { memo, splitProps } from '../helpers.js';
+import { createRecipe, mergeRecipes } from './create-recipe.js';
+
+const textFn = /* @__PURE__ */ createRecipe('text', {
+  "textStyle": "body-md"
+}, [])
+
+const textVariantMap = {
+  "textStyle": [
+    "display-lg",
+    "display-md",
+    "display-sm",
+    "display-xs",
+    "heading-lg",
+    "heading-md",
+    "heading-sm",
+    "heading-xs",
+    "body-lg",
+    "body-md",
+    "body-sm",
+    "body-xs",
+    "mono-lg",
+    "mono-md",
+    "mono-sm",
+    "mono-xs"
+  ],
+  "family": [
+    "heading",
+    "body",
+    "mono"
+  ],
+  "bold": [
+    "true"
+  ],
+  "italic": [
+    "true"
+  ],
+  "underline": [
+    "true"
+  ],
+  "size": [
+    "12",
+    "14",
+    "16",
+    "20",
+    "24",
+    "32",
+    "40",
+    "48",
+    "64",
+    "72",
+    "80",
+    "96"
+  ],
+  "weight": [
+    "light",
+    "normal",
+    "medium",
+    "bold",
+    "black"
+  ]
+}
+
+const textVariantKeys = Object.keys(textVariantMap)
+
+export const text = /* @__PURE__ */ Object.assign(memo(textFn.recipeFn), {
+  __recipe__: true,
+  __name__: 'text',
+  __getCompoundVariantCss__: textFn.__getCompoundVariantCss__,
+  raw: (props) => props,
+  variantKeys: textVariantKeys,
+  variantMap: textVariantMap,
+  merge(recipe) {
+    return mergeRecipes(this, recipe)
+  },
+  splitVariantProps(props) {
+    return splitProps(props, textVariantKeys)
+  },
+  getVariantProps: textFn.getVariantProps,
+})

package/styled-system/recipes/text.mjs

@@ -0,0 +1,80 @@
+import { memo, splitProps } from '../helpers.mjs';
+import { createRecipe, mergeRecipes } from './create-recipe.mjs';
+
+const textFn = /* @__PURE__ */ createRecipe('text', {
+  "textStyle": "body-md"
+}, [])
+
+const textVariantMap = {
+  "textStyle": [
+    "display-lg",
+    "display-md",
+    "display-sm",
+    "display-xs",
+    "heading-lg",
+    "heading-md",
+    "heading-sm",
+    "heading-xs",
+    "body-lg",
+    "body-md",
+    "body-sm",
+    "body-xs",
+    "mono-lg",
+    "mono-md",
+    "mono-sm",
+    "mono-xs"
+  ],
+  "family": [
+    "heading",
+    "body",
+    "mono"
+  ],
+  "bold": [
+    "true"
+  ],
+  "italic": [
+    "true"
+  ],
+  "underline": [
+    "true"
+  ],
+  "size": [
+    "12",
+    "14",
+    "16",
+    "20",
+    "24",
+    "32",
+    "40",
+    "48",
+    "64",
+    "72",
+    "80",
+    "96"
+  ],
+  "weight": [
+    "light",
+    "normal",
+    "medium",
+    "bold",
+    "black"
+  ]
+}
+
+const textVariantKeys = Object.keys(textVariantMap)
+
+export const text = /* @__PURE__ */ Object.assign(memo(textFn.recipeFn), {
+  __recipe__: true,
+  __name__: 'text',
+  __getCompoundVariantCss__: textFn.__getCompoundVariantCss__,
+  raw: (props) => props,
+  variantKeys: textVariantKeys,
+  variantMap: textVariantMap,
+  merge(recipe) {
+    return mergeRecipes(this, recipe)
+  },
+  splitVariantProps(props) {
+    return splitProps(props, textVariantKeys)
+  },
+  getVariantProps: textFn.getVariantProps,
+})

package/styled-system/recipes/textarea.d.ts

@@ -0,0 +1,31 @@
+/* eslint-disable */
+import type { ConditionalValue } from '../types/index';
+import type { DistributiveOmit, Pretty } from '../types/system-types';
+
+interface TextareaVariant {
+  /**
+ * @default "autoGrow"
+ */
+variant: "autoGrow" | "stacked" | "internalLabel"
+}
+
+type TextareaVariantMap = {
+  [key in keyof TextareaVariant]: Array<TextareaVariant[key]>
+}
+
+export type TextareaVariantProps = {
+  [key in keyof TextareaVariant]?: ConditionalValue<TextareaVariant[key]> | undefined
+}
+
+export interface TextareaRecipe {
+  __type: TextareaVariantProps
+  (props?: TextareaVariantProps): string
+  raw: (props?: TextareaVariantProps) => TextareaVariantProps
+  variantMap: TextareaVariantMap
+  variantKeys: Array<keyof TextareaVariant>
+  splitVariantProps<Props extends TextareaVariantProps>(props: Props): [TextareaVariantProps, Pretty<DistributiveOmit<Props, keyof TextareaVariantProps>>]
+  getVariantProps: (props?: TextareaVariantProps) => TextareaVariantProps
+}
+
+
+export declare const textarea: TextareaRecipe