-TABLE` marker pair |
+| Sidebar config | `sidebars.js` |
+| Doc ID format | `drivers/TSF-85/SDK/C++/index` |
diff --git a/docs/drivers.mdx b/docs/drivers.mdx
deleted file mode 100644
index f9e5b29..0000000
--- a/docs/drivers.mdx
+++ /dev/null
@@ -1,54 +0,0 @@
----
-sidebar_position: 1
----
-
-# Drivers
-
-Select a driver below to get started with your Robotiq hardware.
-
-
-export const C = () => Third party ;
-
-export const N = () => New ;
-
-
-## Drivers for low-level coding
-
-Robotiq hardware communication protocols are described in detail in the product manuals, which serve as the authoritative reference for developing custom drivers.
-
-Below are some low-level drivers developed by Robotiq and third parties.
-
-Feel free to contact Robotiq to share your driver needs — we will investigate development possibilities.
-
-| Hardware | Docs | Python | C++ |
-|---|---|---|---|
-| 2F-85 | [Manual](https://robotiq.com/support) | [pyRobotiqGripper](https://github.com/castetsb/pyRobotiqGripper)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
The FT300-S measures forces (Fx, Fy, Fz) and torques (Tx, Ty, Tz) on all six axes.
-
+
**Typical applications:**
diff --git a/external/tactile_sensors b/external/tactile_sensors
new file mode 160000
index 0000000..51948f3
--- /dev/null
+++ b/external/tactile_sensors
@@ -0,0 +1 @@
+Subproject commit 51948f3102b4eb660ce1f941ef2de792f85f4837
diff --git a/package-lock.json b/package-lock.json
index 36aed42..6bc892f 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -19,7 +19,8 @@
},
"devDependencies": {
"@docusaurus/module-type-aliases": "3.10.1",
- "@docusaurus/types": "3.10.1"
+ "@docusaurus/types": "3.10.1",
+ "gray-matter": "^4.0.3"
},
"engines": {
"node": ">=20.0"
diff --git a/package.json b/package.json
index df59d9b..10db045 100644
--- a/package.json
+++ b/package.json
@@ -4,10 +4,13 @@
"private": true,
"scripts": {
"docusaurus": "docusaurus",
+ "generate": "node scripts/sync-external-docs.js && node scripts/generate-tools-table.js",
+ "prestart": "npm run generate",
"start": "docusaurus start",
+ "prebuild": "npm run generate",
"build": "docusaurus build",
+ "test": "node scripts/check-build.js",
"swizzle": "docusaurus swizzle",
- "deploy": "docusaurus deploy",
"clear": "docusaurus clear",
"serve": "docusaurus serve",
"write-translations": "docusaurus write-translations",
@@ -25,7 +28,8 @@
},
"devDependencies": {
"@docusaurus/module-type-aliases": "3.10.1",
- "@docusaurus/types": "3.10.1"
+ "@docusaurus/types": "3.10.1",
+ "gray-matter": "^4.0.3"
},
"browserslist": {
"production": [
diff --git a/preview.sh b/preview.sh
new file mode 100755
index 0000000..16acc34
--- /dev/null
+++ b/preview.sh
@@ -0,0 +1,21 @@
+#!/usr/bin/env bash
+# Locally visualize the documentation website.
+# Usage: ./preview.sh [port] (default port: 3000)
+set -euo pipefail
+
+cd "$(dirname "$0")"
+PORT="${1:-3000}"
+
+# 1. Make sure submodules (external repo docs) are present.
+echo "==> Syncing git submodules..."
+git submodule update --init --recursive
+
+# 2. Install dependencies only if needed.
+if [ ! -d node_modules ]; then
+ echo "==> Installing npm dependencies..."
+ npm install
+fi
+
+# 3. Start the dev server (prestart syncs external docs + regenerates the tools table).
+echo "==> Starting Docusaurus at http://localhost:${PORT}/ (Ctrl+C to stop)"
+npm run start -- --port "${PORT}"
diff --git a/scripts/check-build.js b/scripts/check-build.js
new file mode 100644
index 0000000..a407f90
--- /dev/null
+++ b/scripts/check-build.js
@@ -0,0 +1,63 @@
+// Basic "the docs are not broken" smoke test, run against the production
+// build produced by `npm run build`.
+//
+// Docusaurus already fails the build on broken internal links / anchors
+// (onBrokenLinks: 'throw' in docusaurus.config.js), so a successful build is
+// most of the guarantee. This script adds a few cheap sanity checks on top:
+// 1. the build actually happened,
+// 2. the key pages were emitted, and
+// 3. the auto-generated tools table was injected into the intro page
+// (catches a silently-broken generate-tools-table.js).
+//
+// Usage: npm run build && npm test
+
+const fs = require('fs');
+const path = require('path');
+
+const ROOT = path.resolve(__dirname, '..');
+const BUILD_DIR = path.join(ROOT, 'build');
+
+// Stable routes that should always be generated. Kept deliberately short so
+// the test doesn't turn into a mirror of the sidebar — it's a smoke test.
+const REQUIRED_PAGES = [
+ 'index.html',
+ '404.html',
+ 'docs/intro/index.html',
+ 'docs/contribute/index.html',
+ 'docs/drivers/TSF-85/index.html',
+];
+
+const errors = [];
+
+if (!fs.existsSync(BUILD_DIR)) {
+ console.error('[check-build] No build/ directory found. Run `npm run build` first.');
+ process.exit(1);
+}
+
+for (const page of REQUIRED_PAGES) {
+ if (!fs.existsSync(path.join(BUILD_DIR, page))) {
+ errors.push(`missing expected page: ${page}`);
+ }
+}
+
+// The intro page must contain the generated tools table (a rendered
+// with at least one shields.io support badge). If the generator no-ops or
+// breaks, the section renders empty and this catches it.
+const introPath = path.join(BUILD_DIR, 'docs/intro/index.html');
+if (fs.existsSync(introPath)) {
+ const intro = fs.readFileSync(introPath, 'utf8');
+ if (!intro.includes('');
+ }
+ if (!intro.includes('img.shields.io/badge')) {
+ errors.push('docs/intro tools table has no support badges (generator likely no-op)');
+ }
+}
+
+if (errors.length) {
+ console.error('[check-build] FAILED:');
+ for (const e of errors) console.error(' - ' + e);
+ process.exit(1);
+}
+
+console.log(`[check-build] OK — ${REQUIRED_PAGES.length} pages present, tools table generated.`);
diff --git a/scripts/generate-tools-table.js b/scripts/generate-tools-table.js
new file mode 100644
index 0000000..17ecbe5
--- /dev/null
+++ b/scripts/generate-tools-table.js
@@ -0,0 +1,346 @@
+// Regenerates the software-tools tables by scanning docs/drivers/:
+// - one table per category (SDK, Physics Engine, Other) in docs/intro.mdx
+// and on each product's own index.mdx, all products x tools in that category
+// - one distro-compatibility table per ROS generation (ROS2, ROS1) in
+// docs/intro.mdx and on each product's own index.mdx, all products x distros
+//
+// Each product (hardware) is a folder under docs/drivers/ with its own
+// index.mdx (frontmatter title = row label). Underneath, tool pages are
+// found by walking the folder tree until an index.mdx with a
+// `Category-` shields.io badge is found — that page is a leaf ("tool")
+// classified into that category, regardless of how deep it's nested (e.g.
+// docs/drivers//SDK/Python/index.mdx or docs/drivers//ROS/ROS2/index.mdx).
+// Plain folders in between (SDK/, ROS/, Physics Engine/) are just containers.
+//
+// Non-ROS tool pages carry a single `Supported_by--` badge,
+// shown compactly as the table cell.
+//
+// ROS tool pages (Category-ROS1 / Category-ROS2) instead carry one or more
+// `Distro-` badges, each immediately followed by its own
+// `Supported_by--` badge — one pair per ROS distro that page
+// supports. Those pairs become the columns of the ROS compatibility table.
+//
+// Add a new hardware folder, tool page, or distro badge under docs/drivers/
+// and every table picks it up automatically on the next `npm start` / `npm run build`.
+
+const fs = require('fs');
+const path = require('path');
+const matter = require('gray-matter');
+
+const ROOT = path.resolve(__dirname, '..');
+const DRIVERS_DIR = path.join(ROOT, 'docs', 'drivers');
+const INTRO_FILE = path.join(ROOT, 'docs', 'intro.mdx');
+
+// Non-ROS categories: rendered as a plain "product x tool" table.
+const CATEGORIES = ['SDK', 'Physics_Engine', 'Other'];
+const CATEGORY_DISPLAY = {
+ SDK: 'SDK',
+ Physics_Engine: 'Physics Engine',
+ Other: 'Other',
+};
+const NO_PRODUCTS_MESSAGE = {
+ SDK: '_No SDK drivers documented yet._',
+ Physics_Engine: '_No physics engine integrations documented yet._',
+ Other: '_No other community integrations documented yet._',
+};
+
+// ROS categories: rendered as a "product x distro" compatibility table.
+const ROS_CATEGORIES = ['ROS2', 'ROS1'];
+const NO_ROS_MESSAGE = {
+ ROS2: '_No products currently support ROS 2._',
+ ROS1: '_No products currently support ROS 1._',
+};
+
+// Preferred left-to-right column/distro order. Anything not listed here
+// still appears automatically — it's just sorted alphabetically after these.
+const COLUMN_ORDER = {
+ SDK: ['C', 'C++', 'Python'],
+ Physics_Engine: ['Isaac Sim', 'PyBullet'],
+ Other: [],
+};
+const DISTRO_ORDER = {
+ ROS2: ['Foxy', 'Galactic', 'Humble', 'Iron', 'Jazzy', 'Rolling'],
+ ROS1: ['Indigo', 'Jade', 'Kinetic', 'Melodic', 'Noetic'],
+};
+
+// One-line description shown in the legend below each ROS compatibility
+// table. A distro missing here still gets its own column — it just has no
+// legend entry until one is added.
+const DISTRO_DESCRIPTIONS = {
+ 'Foxy': 'ROS 2 LTS release (2020), end of life.',
+ 'Galactic': 'ROS 2 release (2021), end of life.',
+ 'Humble': 'ROS 2 LTS release (2022), supported until 2027.',
+ 'Iron': 'ROS 2 release (2023), end of life.',
+ 'Jazzy': 'ROS 2 LTS release (2024), supported until 2029.',
+ 'Rolling': 'ROS 2 rolling development distro, always tracking the latest sources.',
+ 'Indigo': 'ROS 1 release (2014), end of life.',
+ 'Jade': 'ROS 1 release (2015), end of life.',
+ 'Kinetic': 'ROS 1 release (2016), end of life.',
+ 'Melodic': 'ROS 1 release (2018), end of life.',
+ 'Noetic': 'Final ROS 1 release (2020), end of life May 2025.',
+};
+
+// One-line description shown in the legend below each category table. A
+// column missing here still appears — it just has no legend entry.
+const COLUMN_DESCRIPTIONS = {
+ 'C': 'Low-level C driver talking directly to the hardware\'s communication protocol (e.g. Modbus RTU, serial).',
+ 'C++': 'Low-level C++ driver/SDK for direct hardware integration.',
+ 'Python': 'Python driver/SDK for scripting and rapid prototyping.',
+ 'Isaac Sim': 'NVIDIA Isaac Sim integration for simulating the hardware.',
+ 'PyBullet': 'PyBullet integration for physics-based simulation.',
+ 'GraspGen': 'NVIDIA GraspGen asset/model package with Robotiq gripper definitions for grasp synthesis research.',
+};
+
+const START_MARKER = (key) => `{/* AUTO-GENERATED-${key}-TABLE:START */}`;
+const END_MARKER = (key) => `{/* AUTO-GENERATED-${key}-TABLE:END */}`;
+
+// Frontmatter is parsed with gray-matter (already a transitive dependency of
+// Docusaurus, declared directly here) rather than a hand-rolled regex, so
+// quoted values and colons inside a title (e.g. `title: "Foo: bar"`) parse
+// correctly instead of producing a wrong column key.
+function readFrontmatterTitle(raw) {
+ const { data } = matter(raw);
+ return typeof data.title === 'string' ? data.title.trim() : null;
+}
+
+function readCategory(raw) {
+ const m = raw.match(/badge\/Category-([A-Za-z0-9_]+)-[A-Za-z0-9]+\)/);
+ return m ? m[1] : null;
+}
+
+// Reads the page's own "Supported by " badge and returns a compact
+// version for the table — same label/color, without the "Supported by"
+// prefix — so the table stays dense. The source page's badge is untouched.
+function readCompactBadge(raw) {
+ const badge = raw.match(/badge\/Supported_by-([A-Za-z0-9_]+)-([A-Za-z0-9]+)/);
+ if (!badge) return null;
+ const [, label, color] = badge;
+ const displayLabel = label.replace(/_/g, ' ');
+ return ``;
+}
+
+// Reads each Distro badge paired with the Supported_by badge immediately
+// following it — one pair per ROS distro the page supports.
+function readDistroSupportPairs(raw) {
+ const pairs = [];
+ const re = /badge\/Distro-([A-Za-z0-9_]+)-[A-Za-z0-9]+\)[\s\S]*?badge\/Supported_by-([A-Za-z0-9_]+)-([A-Za-z0-9]+)\)/g;
+ let m;
+ while ((m = re.exec(raw))) {
+ const [, distro, label, color] = m;
+ const displayLabel = label.replace(/_/g, ' ');
+ pairs.push({
+ distro: distro.replace(/_/g, ' '),
+ badge: ``,
+ });
+ }
+ return pairs;
+}
+
+function docHref(...segments) {
+ // Escape characters that would break Markdown link syntax or be misread as
+ // a URL fragment/query (space, #, ?, %) — everything else (e.g. the "+" in
+ // "C++") must stay literal to match the page's actual URL.
+ return segments.map((s) => s.replace(/[ #?%]/g, (c) => encodeURIComponent(c))).join('/');
+}
+
+function isDirectory(p) {
+ return fs.statSync(p).isDirectory();
+}
+
+// Walks a hardware folder looking for tool leaf pages: an index.mdx carrying
+// a Category badge. Recurses through plain container folders (SDK/, ROS/,
+// Physics Engine/, ...) that have no such index.mdx of their own.
+function collectToolPages(dir, hardwareDir) {
+ const found = [];
+ for (const name of fs.readdirSync(dir).sort()) {
+ const full = path.join(dir, name);
+ if (!isDirectory(full)) continue;
+
+ const indexPath = path.join(full, 'index.mdx');
+ if (fs.existsSync(indexPath)) {
+ const raw = fs.readFileSync(indexPath, 'utf8');
+ const category = readCategory(raw);
+ if (category) {
+ found.push({
+ indexPath,
+ raw,
+ category,
+ relSegments: path.relative(hardwareDir, full).split(path.sep),
+ title: readFrontmatterTitle(raw) || name,
+ });
+ continue;
+ }
+ }
+ found.push(...collectToolPages(full, hardwareDir));
+ }
+ return found;
+}
+
+// product: { title, href, indexPath, tools: { SDK: { toolTitle -> {href, localHref, badge} }, ... },
+// ros: { ROS2: {href, localHref, pairs: [{distro, badge}]}, ... } }
+const products = [];
+const categoryColumns = { SDK: new Set(), Physics_Engine: new Set(), Other: new Set() };
+const rosDistros = { ROS2: new Set(), ROS1: new Set() };
+
+for (const hardwareName of fs.readdirSync(DRIVERS_DIR).sort()) {
+ const hardwareDir = path.join(DRIVERS_DIR, hardwareName);
+ if (!isDirectory(hardwareDir)) continue;
+
+ const hardwareIndex = path.join(hardwareDir, 'index.mdx');
+ if (!fs.existsSync(hardwareIndex)) continue;
+
+ const product = {
+ title: readFrontmatterTitle(fs.readFileSync(hardwareIndex, 'utf8')) || hardwareName,
+ href: docHref('drivers', hardwareName),
+ indexPath: hardwareIndex,
+ tools: { SDK: {}, Physics_Engine: {}, Other: {} },
+ ros: {},
+ };
+
+ for (const tool of collectToolPages(hardwareDir, hardwareDir)) {
+ const href = docHref('drivers', hardwareName, ...tool.relSegments);
+ const localHref = docHref(...tool.relSegments);
+
+ if (tool.category === 'ROS1' || tool.category === 'ROS2') {
+ const pairs = readDistroSupportPairs(tool.raw);
+ product.ros[tool.category] = { href, localHref, pairs };
+ pairs.forEach((p) => rosDistros[tool.category].add(p.distro));
+ continue;
+ }
+
+ if (!CATEGORIES.includes(tool.category)) continue; // unknown category badge — ignore
+ categoryColumns[tool.category].add(tool.title);
+ product.tools[tool.category][tool.title] = {
+ href,
+ localHref,
+ badge: readCompactBadge(tool.raw),
+ };
+ }
+
+ products.push(product);
+}
+
+function byOrder(order) {
+ return (a, b) => {
+ const ra = order.indexOf(a);
+ const rb = order.indexOf(b);
+ if (ra === -1 && rb === -1) return a.localeCompare(b);
+ if (ra === -1) return 1;
+ if (rb === -1) return -1;
+ return ra - rb;
+ };
+}
+
+function buildCategoryTable(catKey, productList, { local } = {}) {
+ const columns = [...categoryColumns[catKey]].sort(byOrder(COLUMN_ORDER[catKey] || []));
+ const relevant = productList.filter((p) => Object.keys(p.tools[catKey]).length > 0);
+ if (!columns.length || !relevant.length) return null;
+
+ const header = `| Product | ${columns.join(' | ')} |`;
+ const separator = `|${'---|'.repeat(columns.length + 1)}`;
+ const rows = relevant.map((p) => {
+ const cells = columns.map((col) => {
+ const tool = p.tools[catKey][col];
+ if (!tool) return '-';
+ const href = local ? tool.localHref : tool.href;
+ return tool.badge ? `[${tool.badge}](${href})` : `[${col}](${href})`;
+ });
+ const productCell = local ? p.title : `[${p.title}](${p.href})`;
+ return `| ${productCell} | ${cells.join(' | ')} |`;
+ });
+
+ return [header, separator, ...rows].join('\n');
+}
+
+function buildRosTable(rosKey, productList, { local } = {}) {
+ const distros = [...rosDistros[rosKey]].sort(byOrder(DISTRO_ORDER[rosKey] || []));
+ const relevant = productList.filter((p) => p.ros[rosKey]);
+ if (!distros.length || !relevant.length) return null;
+
+ const header = `| ${rosKey} | ${distros.join(' | ')} |`;
+ const separator = `|${'---|'.repeat(distros.length + 1)}`;
+ const rows = relevant.map((p) => {
+ const entry = p.ros[rosKey];
+ const href = local ? entry.localHref : entry.href;
+ const cells = distros.map((distro) => {
+ const pair = entry.pairs.find((pp) => pp.distro === distro);
+ return pair ? `[${pair.badge}](${href})` : '-';
+ });
+ const productCell = local ? p.title : `[${p.title}](${p.href})`;
+ return `| ${productCell} | ${cells.join(' | ')} |`;
+ });
+
+ return [header, separator, ...rows].join('\n');
+}
+
+function legendFor(catKey) {
+ return [...categoryColumns[catKey]]
+ .sort(byOrder(COLUMN_ORDER[catKey] || []))
+ .filter((col) => COLUMN_DESCRIPTIONS[col])
+ .map((col) => `- **${col}** — ${COLUMN_DESCRIPTIONS[col]}`)
+ .join('\n');
+}
+
+function legendForRos(rosKey) {
+ return [...rosDistros[rosKey]]
+ .sort(byOrder(DISTRO_ORDER[rosKey] || []))
+ .filter((distro) => DISTRO_DESCRIPTIONS[distro])
+ .map((distro) => `- **${distro}** — ${DISTRO_DESCRIPTIONS[distro]}`)
+ .join('\n');
+}
+
+function escapeRegExp(str) {
+ return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+function writeBetweenMarkers(filePath, key, content) {
+ const startMarker = START_MARKER(key);
+ const endMarker = END_MARKER(key);
+ const raw = fs.readFileSync(filePath, 'utf8');
+ const markerRegex = new RegExp(`${escapeRegExp(startMarker)}[\\s\\S]*?${escapeRegExp(endMarker)}`);
+
+ if (!markerRegex.test(raw)) {
+ throw new Error(
+ `[generate-tools-table] Markers not found in ${path.relative(ROOT, filePath)}. Add ${startMarker} and ${endMarker} where the table should be inserted.`
+ );
+ }
+
+ const block = `${startMarker}\n${content}\n${endMarker}`;
+ fs.writeFileSync(filePath, raw.replace(markerRegex, block), 'utf8');
+}
+
+// --- docs/intro.mdx: one table per category, across all products ---
+
+for (const catKey of CATEGORIES) {
+ const table = buildCategoryTable(catKey, products, { local: false });
+ const legend = table ? legendFor(catKey) : '';
+ const content = table ? [table, legend].filter(Boolean).join('\n\n') : NO_PRODUCTS_MESSAGE[catKey];
+ writeBetweenMarkers(INTRO_FILE, catKey.toUpperCase(), content);
+}
+
+for (const rosKey of ROS_CATEGORIES) {
+ const table = buildRosTable(rosKey, products, { local: false });
+ const legend = table ? legendForRos(rosKey) : '';
+ const content = table ? [table, legend].filter(Boolean).join('\n\n') : NO_ROS_MESSAGE[rosKey];
+ writeBetweenMarkers(INTRO_FILE, rosKey, content);
+}
+
+console.log(`[generate-tools-table] Wrote ${CATEGORIES.length + ROS_CATEGORIES.length} category tables to docs/intro.mdx`);
+
+// --- each product's own index.mdx: same tables, scoped to that one product ---
+
+for (const product of products) {
+ for (const catKey of CATEGORIES) {
+ const table = buildCategoryTable(catKey, [product], { local: true });
+ const legend = table ? legendFor(catKey) : '';
+ const content = table ? [table, legend].filter(Boolean).join('\n\n') : NO_PRODUCTS_MESSAGE[catKey];
+ writeBetweenMarkers(product.indexPath, `PRODUCT-${catKey.toUpperCase()}`, content);
+ }
+ for (const rosKey of ROS_CATEGORIES) {
+ const table = buildRosTable(rosKey, [product], { local: true });
+ const legend = table ? legendForRos(rosKey) : '';
+ const content = table ? [table, legend].filter(Boolean).join('\n\n') : NO_ROS_MESSAGE[rosKey];
+ writeBetweenMarkers(product.indexPath, `PRODUCT-${rosKey}`, content);
+ }
+ console.log(`[generate-tools-table] Wrote category tables to ${path.relative(ROOT, product.indexPath)}`);
+}
diff --git a/scripts/sync-external-docs.js b/scripts/sync-external-docs.js
new file mode 100644
index 0000000..bd18ca0
--- /dev/null
+++ b/scripts/sync-external-docs.js
@@ -0,0 +1,167 @@
+// Copies content from git submodules into the Docusaurus docs tree.
+// Supports single files and full folders. Add new repos to JOBS below.
+//
+// Single-file job: all relative links become absolute GitHub URLs.
+// Folder job: links within the copied folder stay relative;
+// links escaping the folder become absolute GitHub URLs.
+
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+
+const ROOT = path.resolve(__dirname, '..');
+
+// Reset all submodules to the committed state before syncing,
+// so local edits inside external/ never silently affect the build.
+try {
+ execSync('git submodule update --init --force', { cwd: ROOT, stdio: 'inherit' });
+} catch {
+ console.warn('[sync-external-docs] git submodule update failed — continuing with current state');
+}
+
+// ── Add new repos here ─────────────────────────────────────────────────────
+const JOBS = [
+ // TSF 85 CPP driver README
+ {
+ submodule: 'tactile_sensors',
+ repoUrl: 'https://github.com/robotiq/tactile_sensors',
+ branch: 'main',
+ from: 'sdk_cpp/README.md',
+ to: 'drivers/TSF-85/SDK/C++/_readme.md',
+ },
+ // TSF 85 Python driver README
+ {
+ submodule: 'tactile_sensors',
+ repoUrl: 'https://github.com/robotiq/tactile_sensors',
+ branch: 'main',
+ from: 'sensor_quickstart/README.md',
+ to: 'drivers/TSF-85/SDK/Python/_readme.md',
+ },
+ // Folder example — uncomment when a repo has a docs/ folder:
+ // {
+ // submodule: 'tactile_sensors',
+ // repoUrl: 'https://github.com/Robotiq/tactile_sensors',
+ // branch: 'main',
+ // from: 'docs',
+ // to: 'drivers/tsf-85',
+ // },
+];
+// ───────────────────────────────────────────────────────────────────────────
+
+const MARKDOWN_EXTS = new Set(['.md', '.mdx']);
+const COPY_EXTS = new Set(['.md', '.mdx', '.png', '.jpg', '.jpeg', '.gif', '.svg', '.webp', '.pdf']);
+
+function isAbsoluteHref(href) {
+ return /^(https?:\/\/|mailto:|#|\/)/.test(href);
+}
+
+// Rewrites markdown links in `content`.
+// srcFile / destFile : absolute paths of the file being processed
+// copiedRoot : if non-null, the source folder being synced as a whole.
+// Links that resolve inside it are re-expressed as relative paths
+// from the destination file. Pass null for single-file syncs.
+// destCopiedRoot : destination counterpart of copiedRoot (null for single-file)
+// submoduleRoot : absolute path to the submodule root
+// repoUrl / branch : used to build absolute GitHub URLs
+function rewriteLinks(content, { srcFile, destFile, copiedRoot, destCopiedRoot, submoduleRoot, repoUrl, branch }) {
+ const srcDir = path.dirname(srcFile);
+ const destDir = path.dirname(destFile);
+
+ // Strip content wrapped in ... .
+ // Lets a submodule README carry a "full docs at " blurb that renders on GitHub
+ // but never makes it into the synced docs page.
+ content = content.replace(/[\s\S]*?\n?/g, '');
+
+ // Strip the leading H1 — the wrapper .mdx supplies the page title via
+ // sidebar_label frontmatter. Uses 'm' (without 'g') so it finds the first
+ // "# " line anywhere near the top and removes only that one match, even
+ // when the README opens with a badge or blank line before its title.
+ content = content.replace(/^# .*\n+/m, '');
+
+ // Convert autolinks to [url](url) — MDX treats angle-bracket URLs as JSX and fails.
+ content = content.replace(/<(https?:\/\/[^>\s]+)>/g, '[$1]($1)');
+
+ return content.replace(/(!?)\[([^\]]*)\]\(([^)\n]+)\)/g, (match, bang, text, href) => {
+ const hashIdx = href.indexOf('#');
+ const hrefPath = hashIdx >= 0 ? href.slice(0, hashIdx) : href;
+ const anchor = hashIdx >= 0 ? href.slice(hashIdx) : '';
+
+ if (!hrefPath.trim() || isAbsoluteHref(hrefPath)) return match;
+
+ const absTarget = path.resolve(srcDir, hrefPath);
+
+ if (copiedRoot) {
+ const relToRoot = path.relative(copiedRoot, absTarget);
+ if (!relToRoot.startsWith('..')) {
+ // Target is inside the copied folder — rewrite as a relative path from dest
+ const absDestTarget = path.join(destCopiedRoot, relToRoot);
+ const newRel = path.relative(destDir, absDestTarget).replace(/\\/g, '/');
+ return `${bang}[${text}](${newRel}${anchor})`;
+ }
+ }
+
+ // Target escapes the copied content — make it an absolute GitHub URL.
+ // Image embeds (`![...]`) need the raw file bytes to render as an
diff --git a/static/img/Ros_logo.svg.png b/static/img/Ros_logo.svg.png
deleted file mode 100644
index b94e2c1..0000000
Binary files a/static/img/Ros_logo.svg.png and /dev/null differ
diff --git a/static/img/images.jpg b/static/img/graspgen.jpg
similarity index 100%
rename from static/img/images.jpg
rename to static/img/graspgen.jpg
diff --git a/static/img/ros1.png b/static/img/ros1.png
new file mode 100644
index 0000000..0e99936
Binary files /dev/null and b/static/img/ros1.png differ
diff --git a/static/img/ros2.webp b/static/img/ros2.webp
new file mode 100644
index 0000000..a3b7c3f
Binary files /dev/null and b/static/img/ros2.webp differ