crca 1.4.0__py3-none-any.whl

tools/bolt.diy/app/utils/markdown.ts

@@ -0,0 +1,155 @@
+import rehypeRaw from 'rehype-raw';
+import remarkGfm from 'remark-gfm';
+import type { PluggableList, Plugin } from 'unified';
+import rehypeSanitize, { defaultSchema, type Options as RehypeSanitizeOptions } from 'rehype-sanitize';
+import { SKIP, visit } from 'unist-util-visit';
+import type { UnistNode, UnistParent } from 'node_modules/unist-util-visit/lib';
+
+export const allowedHTMLElements = [
+  'a',
+  'b',
+  'button',
+  'blockquote',
+  'br',
+  'code',
+  'dd',
+  'del',
+  'details',
+  'div',
+  'dl',
+  'dt',
+  'em',
+  'h1',
+  'h2',
+  'h3',
+  'h4',
+  'h5',
+  'h6',
+  'hr',
+  'i',
+  'ins',
+  'kbd',
+  'li',
+  'ol',
+  'p',
+  'pre',
+  'q',
+  'rp',
+  'rt',
+  'ruby',
+  's',
+  'samp',
+  'source',
+  'span',
+  'strike',
+  'strong',
+  'sub',
+  'summary',
+  'sup',
+  'table',
+  'tbody',
+  'td',
+  'tfoot',
+  'th',
+  'thead',
+  'tr',
+  'ul',
+  'var',
+  'think',
+  'header',
+];
+
+// Add custom rehype plugin
+function remarkThinkRawContent() {
+  return (tree: any) => {
+    visit(tree, (node: any) => {
+      if (node.type === 'html' && node.value && node.value.startsWith('<think>')) {
+        const cleanedContent = node.value.slice(7);
+        node.value = `<div class="__boltThought__">${cleanedContent}`;
+
+        return;
+      }
+
+      if (node.type === 'html' && node.value && node.value.startsWith('</think>')) {
+        const cleanedContent = node.value.slice(8);
+        node.value = `</div>${cleanedContent}`;
+      }
+    });
+  };
+}
+
+const rehypeSanitizeOptions: RehypeSanitizeOptions = {
+  ...defaultSchema,
+  tagNames: allowedHTMLElements,
+  attributes: {
+    ...defaultSchema.attributes,
+    div: [
+      ...(defaultSchema.attributes?.div ?? []),
+      'data*',
+      ['className', '__boltArtifact__', '__boltThought__', '__boltQuickAction', '__boltSelectedElement__'],
+
+      // ['className', '__boltThought__']
+    ],
+    button: [
+      ...(defaultSchema.attributes?.button ?? []),
+      'data*',
+      'type',
+      'disabled',
+      'name',
+      'value',
+      ['className', '__boltArtifact__', '__boltThought__', '__boltQuickAction'],
+    ],
+  },
+  strip: [],
+};
+
+export function remarkPlugins(limitedMarkdown: boolean) {
+  const plugins: PluggableList = [remarkGfm];
+
+  if (limitedMarkdown) {
+    plugins.unshift(limitedMarkdownPlugin);
+  }
+
+  plugins.unshift(remarkThinkRawContent);
+
+  return plugins;
+}
+
+export function rehypePlugins(html: boolean) {
+  const plugins: PluggableList = [];
+
+  if (html) {
+    plugins.push(rehypeRaw, [rehypeSanitize, rehypeSanitizeOptions]);
+  }
+
+  return plugins;
+}
+
+const limitedMarkdownPlugin: Plugin = () => {
+  return (tree, file) => {
+    const contents = file.toString();
+
+    visit(tree, (node: UnistNode, index, parent: UnistParent) => {
+      if (
+        index == null ||
+        ['paragraph', 'text', 'inlineCode', 'code', 'strong', 'emphasis'].includes(node.type) ||
+        !node.position
+      ) {
+        return true;
+      }
+
+      let value = contents.slice(node.position.start.offset, node.position.end.offset);
+
+      if (node.type === 'heading') {
+        value = `\n${value}`;
+      }
+
+      parent.children[index] = {
+        type: 'text',
+        value,
+      } as any;
+
+      return [SKIP, index] as const;
+    });
+  };
+};

tools/bolt.diy/app/utils/mobile.ts

@@ -0,0 +1,4 @@
+export function isMobile() {
+  // we use sm: as the breakpoint for mobile. It's currently set to 640px
+  return globalThis.innerWidth < 640;
+}

tools/bolt.diy/app/utils/os.ts

@@ -0,0 +1,4 @@
+// Helper to detect OS
+export const isMac = typeof navigator !== 'undefined' ? navigator.platform.toLowerCase().includes('mac') : false;
+export const isWindows = typeof navigator !== 'undefined' ? navigator.platform.toLowerCase().includes('win') : false;
+export const isLinux = typeof navigator !== 'undefined' ? navigator.platform.toLowerCase().includes('linux') : false;

tools/bolt.diy/app/utils/path.ts

@@ -0,0 +1,19 @@
+// Browser-compatible path utilities
+import type { ParsedPath } from 'path';
+import pathBrowserify from 'path-browserify';
+
+/**
+ * A browser-compatible path utility that mimics Node's path module
+ * Using path-browserify for consistent behavior in browser environments
+ */
+export const path = {
+  join: (...paths: string[]): string => pathBrowserify.join(...paths),
+  dirname: (path: string): string => pathBrowserify.dirname(path),
+  basename: (path: string, ext?: string): string => pathBrowserify.basename(path, ext),
+  extname: (path: string): string => pathBrowserify.extname(path),
+  relative: (from: string, to: string): string => pathBrowserify.relative(from, to),
+  isAbsolute: (path: string): boolean => pathBrowserify.isAbsolute(path),
+  normalize: (path: string): string => pathBrowserify.normalize(path),
+  parse: (path: string): ParsedPath => pathBrowserify.parse(path),
+  format: (pathObject: ParsedPath): string => pathBrowserify.format(pathObject),
+} as const;

tools/bolt.diy/app/utils/projectCommands.ts

@@ -0,0 +1,197 @@
+import type { Message } from 'ai';
+import { generateId } from './fileUtils';
+
+export interface ProjectCommands {
+  type: string;
+  setupCommand?: string;
+  startCommand?: string;
+  followupMessage: string;
+}
+
+interface FileContent {
+  content: string;
+  path: string;
+}
+
+// Helper function to make any command non-interactive
+function makeNonInteractive(command: string): string {
+  // Set environment variables for non-interactive mode
+  const envVars = 'export CI=true DEBIAN_FRONTEND=noninteractive FORCE_COLOR=0';
+
+  // Common interactive packages and their non-interactive flags
+  const interactivePackages = [
+    { pattern: /npx\s+([^@\s]+@?[^\s]*)\s+init/g, replacement: 'echo "y" | npx --yes $1 init --defaults --yes' },
+    { pattern: /npx\s+create-([^\s]+)/g, replacement: 'npx --yes create-$1 --template default' },
+    { pattern: /npx\s+([^@\s]+@?[^\s]*)\s+add/g, replacement: 'npx --yes $1 add --defaults --yes' },
+    { pattern: /npm\s+install(?!\s+--)/g, replacement: 'npm install --yes --no-audit --no-fund --silent' },
+    { pattern: /yarn\s+add(?!\s+--)/g, replacement: 'yarn add --non-interactive' },
+    { pattern: /pnpm\s+add(?!\s+--)/g, replacement: 'pnpm add --yes' },
+  ];
+
+  let processedCommand = command;
+
+  // Apply replacements for known interactive patterns
+  interactivePackages.forEach(({ pattern, replacement }) => {
+    processedCommand = processedCommand.replace(pattern, replacement);
+  });
+
+  return `${envVars} && ${processedCommand}`;
+}
+
+export async function detectProjectCommands(files: FileContent[]): Promise<ProjectCommands> {
+  const hasFile = (name: string) => files.some((f) => f.path.endsWith(name));
+  const hasFileContent = (name: string, content: string) =>
+    files.some((f) => f.path.endsWith(name) && f.content.includes(content));
+
+  if (hasFile('package.json')) {
+    const packageJsonFile = files.find((f) => f.path.endsWith('package.json'));
+
+    if (!packageJsonFile) {
+      return { type: '', setupCommand: '', followupMessage: '' };
+    }
+
+    try {
+      const packageJson = JSON.parse(packageJsonFile.content);
+      const scripts = packageJson?.scripts || {};
+      const dependencies = { ...packageJson.dependencies, ...packageJson.devDependencies };
+
+      // Check if this is a shadcn project
+      const isShadcnProject =
+        hasFileContent('components.json', 'shadcn') ||
+        Object.keys(dependencies).some((dep) => dep.includes('shadcn')) ||
+        hasFile('components.json');
+
+      // Check for preferred commands in priority order
+      const preferredCommands = ['dev', 'start', 'preview'];
+      const availableCommand = preferredCommands.find((cmd) => scripts[cmd]);
+
+      // Build setup command with non-interactive handling
+      let baseSetupCommand = 'npx update-browserslist-db@latest && npm install';
+
+      // Add shadcn init if it's a shadcn project
+      if (isShadcnProject) {
+        baseSetupCommand += ' && npx shadcn@latest init';
+      }
+
+      const setupCommand = makeNonInteractive(baseSetupCommand);
+
+      if (availableCommand) {
+        return {
+          type: 'Node.js',
+          setupCommand,
+          startCommand: `npm run ${availableCommand}`,
+          followupMessage: `Found "${availableCommand}" script in package.json. Running "npm run ${availableCommand}" after installation.`,
+        };
+      }
+
+      return {
+        type: 'Node.js',
+        setupCommand,
+        followupMessage:
+          'Would you like me to inspect package.json to determine the available scripts for running this project?',
+      };
+    } catch (error) {
+      console.error('Error parsing package.json:', error);
+      return { type: '', setupCommand: '', followupMessage: '' };
+    }
+  }
+
+  if (hasFile('index.html')) {
+    return {
+      type: 'Static',
+      startCommand: 'npx --yes serve',
+      followupMessage: '',
+    };
+  }
+
+  return { type: '', setupCommand: '', followupMessage: '' };
+}
+
+export function createCommandsMessage(commands: ProjectCommands): Message | null {
+  if (!commands.setupCommand && !commands.startCommand) {
+    return null;
+  }
+
+  let commandString = '';
+
+  if (commands.setupCommand) {
+    commandString += `
+<boltAction type="shell">${commands.setupCommand}</boltAction>`;
+  }
+
+  if (commands.startCommand) {
+    commandString += `
+<boltAction type="start">${commands.startCommand}</boltAction>
+`;
+  }
+
+  return {
+    role: 'assistant',
+    content: `
+${commands.followupMessage ? `\n\n${commands.followupMessage}` : ''}
+<boltArtifact id="project-setup" title="Project Setup">
+${commandString}
+</boltArtifact>`,
+    id: generateId(),
+    createdAt: new Date(),
+  };
+}
+
+export function escapeBoltArtifactTags(input: string) {
+  // Regular expression to match boltArtifact tags and their content
+  const regex = /(<boltArtifact[^>]*>)([\s\S]*?)(<\/boltArtifact>)/g;
+
+  return input.replace(regex, (match, openTag, content, closeTag) => {
+    // Escape the opening tag
+    const escapedOpenTag = openTag.replace(/</g, '&lt;').replace(/>/g, '&gt;');
+
+    // Escape the closing tag
+    const escapedCloseTag = closeTag.replace(/</g, '&lt;').replace(/>/g, '&gt;');
+
+    // Return the escaped version
+    return `${escapedOpenTag}${content}${escapedCloseTag}`;
+  });
+}
+
+export function escapeBoltAActionTags(input: string) {
+  // Regular expression to match boltArtifact tags and their content
+  const regex = /(<boltAction[^>]*>)([\s\S]*?)(<\/boltAction>)/g;
+
+  return input.replace(regex, (match, openTag, content, closeTag) => {
+    // Escape the opening tag
+    const escapedOpenTag = openTag.replace(/</g, '&lt;').replace(/>/g, '&gt;');
+
+    // Escape the closing tag
+    const escapedCloseTag = closeTag.replace(/</g, '&lt;').replace(/>/g, '&gt;');
+
+    // Return the escaped version
+    return `${escapedOpenTag}${content}${escapedCloseTag}`;
+  });
+}
+
+export function escapeBoltTags(input: string) {
+  return escapeBoltArtifactTags(escapeBoltAActionTags(input));
+}
+
+// We have this seperate function to simplify the restore snapshot process in to one single artifact.
+export function createCommandActionsString(commands: ProjectCommands): string {
+  if (!commands.setupCommand && !commands.startCommand) {
+    // Return empty string if no commands
+    return '';
+  }
+
+  let commandString = '';
+
+  if (commands.setupCommand) {
+    commandString += `
+<boltAction type="shell">${commands.setupCommand}</boltAction>`;
+  }
+
+  if (commands.startCommand) {
+    commandString += `
+<boltAction type="start">${commands.startCommand}</boltAction>
+`;
+  }
+
+  return commandString;
+}

tools/bolt.diy/app/utils/promises.ts

@@ -0,0 +1,19 @@
+export function withResolvers<T>(): PromiseWithResolvers<T> {
+  if (typeof Promise.withResolvers === 'function') {
+    return Promise.withResolvers();
+  }
+
+  let resolve!: (value: T | PromiseLike<T>) => void;
+  let reject!: (reason?: any) => void;
+
+  const promise = new Promise<T>((_resolve, _reject) => {
+    resolve = _resolve;
+    reject = _reject;
+  });
+
+  return {
+    resolve,
+    reject,
+    promise,
+  };
+}

tools/bolt.diy/app/utils/react.ts

@@ -0,0 +1,6 @@
+import { memo } from 'react';
+
+export const genericMemo: <T extends keyof JSX.IntrinsicElements | React.JSXElementConstructor<any>>(
+  component: T,
+  propsAreEqual?: (prevProps: React.ComponentProps<T>, nextProps: React.ComponentProps<T>) => boolean,
+) => T & { displayName?: string } = memo;

tools/bolt.diy/app/utils/sampler.ts

@@ -0,0 +1,49 @@
+/**
+ * Creates a function that samples calls at regular intervals and captures trailing calls.
+ * - Drops calls that occur between sampling intervals
+ * - Takes one call per sampling interval if available
+ * - Captures the last call if no call was made during the interval
+ *
+ * @param fn The function to sample
+ * @param sampleInterval How often to sample calls (in ms)
+ * @returns The sampled function
+ */
+export function createSampler<T extends (...args: any[]) => any>(fn: T, sampleInterval: number): T {
+  let lastArgs: Parameters<T> | null = null;
+  let lastTime = 0;
+  let timeout: NodeJS.Timeout | null = null;
+
+  // Create a function with the same type as the input function
+  const sampled = function (this: any, ...args: Parameters<T>) {
+    const now = Date.now();
+    lastArgs = args;
+
+    // If we're within the sample interval, just store the args
+    if (now - lastTime < sampleInterval) {
+      // Set up trailing call if not already set
+      if (!timeout) {
+        timeout = setTimeout(
+          () => {
+            timeout = null;
+            lastTime = Date.now();
+
+            if (lastArgs) {
+              fn.apply(this, lastArgs);
+              lastArgs = null;
+            }
+          },
+          sampleInterval - (now - lastTime),
+        );
+      }
+
+      return;
+    }
+
+    // If we're outside the interval, execute immediately
+    lastTime = now;
+    fn.apply(this, args);
+    lastArgs = null;
+  } as T;
+
+  return sampled;
+}