builder.io 1.0.2-3 → 1.1.13-0

package/figma/index.cjs

@@ -0,0 +1 @@
+"use strict";var t=Object.defineProperty;var p=Object.getOwnPropertyDescriptor;var g=Object.getOwnPropertyNames;var o=Object.prototype.hasOwnProperty;var m=(n,e)=>{for(var a in e)t(n,a,{get:e[a],enumerable:!0})},s=(n,e,a,r)=>{if(e&&typeof e=="object"||typeof e=="function")for(let i of g(e))!o.call(n,i)&&i!==a&&t(n,i,{get:()=>e[i],enumerable:!(r=p(e,i))||r.enumerable});return n};var d=n=>s(t({},"__esModule",{value:!0}),n);var y={};m(y,{figmaMapping:()=>F});module.exports=d(y);function F(n){}

package/figma/index.d.ts

@@ -0,0 +1 @@
+export * from "../types/figma";

package/figma/index.mjs

@@ -0,0 +1 @@
+function n(e){}export{n as figmaMapping};

package/figma/jsx-runtime/index.cjs

@@ -0,0 +1,7 @@
+exports.jsx = function jsx() {
+  return null;
+};
+
+exports.jsxs = function jsxs() {
+  return null;
+};

package/figma/jsx-runtime/index.d.ts

@@ -0,0 +1,46 @@
+// Expose `JSX` namespace in `global` namespace
+import * as React from "./react";
+export { Fragment } from "./react";
+
+export namespace JSX {
+  interface Element extends React.JSX.Element {}
+  interface ElementClass extends React.JSX.ElementClass {}
+  interface ElementAttributesProperty
+    extends React.JSX.ElementAttributesProperty {}
+  interface ElementChildrenAttribute
+    extends React.JSX.ElementChildrenAttribute {}
+  type LibraryManagedAttributes<C, P> = React.JSX.LibraryManagedAttributes<
+    C,
+    P
+  >;
+  interface IntrinsicAttributes extends React.JSX.IntrinsicAttributes {
+    children?: any;
+  }
+  interface IntrinsicClassAttributes<T>
+    extends React.JSX.IntrinsicClassAttributes<T> {
+    children?: any;
+  }
+  interface IntrinsicElements extends React.JSX.IntrinsicElements {}
+}
+
+/**
+ * Create a React element.
+ *
+ * You should not use this function directly. Use JSX and a transpiler instead.
+ */
+export function jsx(
+  type: React.ElementType,
+  props: unknown,
+  key?: React.Key
+): React.ReactElement;
+
+/**
+ * Create a React element.
+ *
+ * You should not use this function directly. Use JSX and a transpiler instead.
+ */
+export function jsxs(
+  type: React.ElementType,
+  props: unknown,
+  key?: React.Key
+): React.ReactElement;

package/figma/jsx-runtime/index.js

@@ -0,0 +1,7 @@
+export function jsx() {
+  return null;
+}
+
+export function jsxs() {
+  return null;
+}

package/figma/jsx-runtime/prop-types.d.ts

@@ -0,0 +1,125 @@
+export type ReactComponentLike =
+  | string
+  | ((props: any, context?: any) => any)
+  | (new (props: any, context?: any) => any);
+
+export interface ReactElementLike {
+  type: ReactComponentLike;
+  props: any;
+  key: string | null;
+}
+
+export interface ReactNodeArray extends Iterable<ReactNodeLike> {}
+
+export type ReactNodeLike =
+  | ReactElementLike
+  | ReactNodeArray
+  | string
+  | number
+  | boolean
+  | null
+  | undefined;
+
+export const nominalTypeHack: unique symbol;
+
+export type IsOptional<T> = undefined extends T ? true : false;
+
+export type RequiredKeys<V> = {
+  [K in keyof V]-?: Exclude<V[K], undefined> extends Validator<infer T>
+    ? IsOptional<T> extends true
+      ? never
+      : K
+    : never;
+}[keyof V];
+export type OptionalKeys<V> = Exclude<keyof V, RequiredKeys<V>>;
+export type InferPropsInner<V> = { [K in keyof V]-?: InferType<V[K]> };
+
+export interface Validator<T> {
+  (
+    props: { [key: string]: any },
+    propName: string,
+    componentName: string,
+    location: string,
+    propFullName: string
+  ): Error | null;
+  [nominalTypeHack]?:
+    | {
+        type: T;
+      }
+    | undefined;
+}
+
+export interface Requireable<T> extends Validator<T | undefined | null> {
+  isRequired: Validator<NonNullable<T>>;
+}
+
+export type ValidationMap<T> = { [K in keyof T]?: Validator<T[K]> };
+
+/**
+ * Like {@link ValidationMap} but treats `undefined`, `null` and optional properties the same.
+ * This type is only added as a migration path in React 19 where this type was removed from React.
+ * Runtime and compile time types would mismatch since you could see `undefined` at runtime when your types don't expect this type.
+ */
+export type WeakValidationMap<T> = {
+  [K in keyof T]?: null extends T[K]
+    ? Validator<T[K] | null | undefined>
+    : undefined extends T[K]
+    ? Validator<T[K] | null | undefined>
+    : Validator<T[K]>;
+};
+
+export type InferType<V> = V extends Validator<infer T> ? T : any;
+export type InferProps<V> = InferPropsInner<Pick<V, RequiredKeys<V>>> &
+  Partial<InferPropsInner<Pick<V, OptionalKeys<V>>>>;
+
+export const any: Requireable<any>;
+export const array: Requireable<any[]>;
+export const bool: Requireable<boolean>;
+export const func: Requireable<(...args: any[]) => any>;
+export const number: Requireable<number>;
+export const object: Requireable<object>;
+export const string: Requireable<string>;
+export const node: Requireable<ReactNodeLike>;
+export const element: Requireable<ReactElementLike>;
+export const symbol: Requireable<symbol>;
+export const elementType: Requireable<ReactComponentLike>;
+export function instanceOf<T>(
+  expectedClass: new (...args: any[]) => T
+): Requireable<T>;
+export function oneOf<T>(types: readonly T[]): Requireable<T>;
+export function oneOfType<T extends Validator<any>>(
+  types: T[]
+): Requireable<NonNullable<InferType<T>>>;
+export function arrayOf<T>(type: Validator<T>): Requireable<T[]>;
+export function objectOf<T>(
+  type: Validator<T>
+): Requireable<{ [K in keyof any]: T }>;
+export function shape<P extends ValidationMap<any>>(
+  type: P
+): Requireable<InferProps<P>>;
+export function exact<P extends ValidationMap<any>>(
+  type: P
+): Requireable<Required<InferProps<P>>>;
+
+/**
+ * Assert that the values match with the type specs.
+ * Error messages are memorized and will only be shown once.
+ *
+ * @param typeSpecs Map of name to a ReactPropType
+ * @param values Runtime values that need to be type-checked
+ * @param location e.g. "prop", "context", "child context"
+ * @param componentName Name of the component for error messages
+ * @param getStack Returns the component stack
+ */
+export function checkPropTypes(
+  typeSpecs: any,
+  values: any,
+  location: string,
+  componentName: string,
+  getStack?: () => any
+): void;
+
+/**
+ * Only available if NODE_ENV=production
+ */
+export function resetWarningCache(): void;