@shuji-bonji/rxjs-mcp 0.2.2 → 0.3.0

package/dist/data/operators.js

@@ -1,4 +1,4 @@
-import { DOC_BASE_URL } from '../types.js';
+import { buildOfficialUrl, buildSourceUrl, buildGuideUrl, } from '../types.js';
 /**
  * RxJS Pipeable Operators Database
  * Based on https://shuji-bonji.github.io/RxJS-with-TypeScript/
@@ -9,492 +9,649 @@ export const operatorDatabase = {
         name: 'map',
         category: 'transformation',
         description: 'Transforms each value by applying a function',
-        docUrl: `${DOC_BASE_URL}/operators/transformation/map`,
+        officialUrl: buildOfficialUrl('operator', 'map'),
+        sourceUrl: buildSourceUrl('operators/map.ts'),
+        guideUrl: buildGuideUrl('operators/transformation/map'),
     },
     'scan': {
         name: 'scan',
         category: 'transformation',
         description: 'Accumulates values over time, emits each step',
-        docUrl: `${DOC_BASE_URL}/operators/transformation/scan`,
+        officialUrl: buildOfficialUrl('operator', 'scan'),
+        sourceUrl: buildSourceUrl('operators/scan.ts'),
+        guideUrl: buildGuideUrl('operators/transformation/scan'),
     },
     'mergeScan': {
         name: 'mergeScan',
         category: 'transformation',
         description: 'Like scan but with inner Observable merging',
-        docUrl: `${DOC_BASE_URL}/operators/transformation/mergeScan`,
+        officialUrl: buildOfficialUrl('operator', 'mergeScan'),
+        sourceUrl: buildSourceUrl('operators/mergeScan.ts'),
+        guideUrl: buildGuideUrl('operators/transformation/mergeScan'),
     },
     'reduce': {
         name: 'reduce',
         category: 'transformation',
         description: 'Accumulates values and emits final result on completion',
-        docUrl: `${DOC_BASE_URL}/operators/transformation/reduce`,
+        officialUrl: buildOfficialUrl('operator', 'reduce'),
+        sourceUrl: buildSourceUrl('operators/reduce.ts'),
+        guideUrl: buildGuideUrl('operators/transformation/reduce'),
     },
     'pairwise': {
         name: 'pairwise',
         category: 'transformation',
         description: 'Emits previous and current value as array',
-        docUrl: `${DOC_BASE_URL}/operators/transformation/pairwise`,
+        officialUrl: buildOfficialUrl('operator', 'pairwise'),
+        sourceUrl: buildSourceUrl('operators/pairwise.ts'),
+        guideUrl: buildGuideUrl('operators/transformation/pairwise'),
     },
     'groupBy': {
         name: 'groupBy',
         category: 'transformation',
         description: 'Groups emissions by key into separate Observables',
-        docUrl: `${DOC_BASE_URL}/operators/transformation/groupBy`,
+        officialUrl: buildOfficialUrl('operator', 'groupBy'),
+        sourceUrl: buildSourceUrl('operators/groupBy.ts'),
+        guideUrl: buildGuideUrl('operators/transformation/groupBy'),
     },
     'mergeMap': {
         name: 'mergeMap',
         category: 'transformation',
         description: 'Projects values to inner Observable, running concurrently',
-        docUrl: `${DOC_BASE_URL}/operators/transformation/mergeMap`,
+        officialUrl: buildOfficialUrl('operator', 'mergeMap'),
+        sourceUrl: buildSourceUrl('operators/mergeMap.ts'),
+        guideUrl: buildGuideUrl('operators/transformation/mergeMap'),
         marblePattern: '-a---b---c--| → -A-B-C-D-E-F-|',
     },
     'switchMap': {
         name: 'switchMap',
         category: 'transformation',
         description: 'Projects values to inner Observable, cancelling previous',
-        docUrl: `${DOC_BASE_URL}/operators/transformation/switchMap`,
+        officialUrl: buildOfficialUrl('operator', 'switchMap'),
+        sourceUrl: buildSourceUrl('operators/switchMap.ts'),
+        guideUrl: buildGuideUrl('operators/transformation/switchMap'),
         marblePattern: '-a---b---c--| → -A-B-C-D-E-F-|',
     },
     'concatMap': {
         name: 'concatMap',
         category: 'transformation',
         description: 'Projects values to inner Observable, waiting for completion',
-        docUrl: `${DOC_BASE_URL}/operators/transformation/concatMap`,
+        officialUrl: buildOfficialUrl('operator', 'concatMap'),
+        sourceUrl: buildSourceUrl('operators/concatMap.ts'),
+        guideUrl: buildGuideUrl('operators/transformation/concatMap'),
         marblePattern: '-a---b---c--| → -A-A-B-B-C-C-|',
     },
     'exhaustMap': {
         name: 'exhaustMap',
         category: 'transformation',
         description: 'Projects values to inner Observable, ignoring new while active',
-        docUrl: `${DOC_BASE_URL}/operators/transformation/exhaustMap`,
+        officialUrl: buildOfficialUrl('operator', 'exhaustMap'),
+        sourceUrl: buildSourceUrl('operators/exhaustMap.ts'),
+        guideUrl: buildGuideUrl('operators/transformation/exhaustMap'),
         marblePattern: '-a---b---c--| → -A-A-A---C-C-|',
     },
     'expand': {
         name: 'expand',
         category: 'transformation',
         description: 'Recursively projects values to inner Observables',
-        docUrl: `${DOC_BASE_URL}/operators/transformation/expand`,
+        officialUrl: buildOfficialUrl('operator', 'expand'),
+        sourceUrl: buildSourceUrl('operators/expand.ts'),
+        guideUrl: buildGuideUrl('operators/transformation/expand'),
     },
     'buffer': {
         name: 'buffer',
         category: 'transformation',
         description: 'Buffers values until notifier emits',
-        docUrl: `${DOC_BASE_URL}/operators/transformation/buffer`,
+        officialUrl: buildOfficialUrl('operator', 'buffer'),
+        sourceUrl: buildSourceUrl('operators/buffer.ts'),
+        guideUrl: buildGuideUrl('operators/transformation/buffer'),
     },
     'bufferTime': {
         name: 'bufferTime',
         category: 'transformation',
         description: 'Buffers values for specified time periods',
-        docUrl: `${DOC_BASE_URL}/operators/transformation/bufferTime`,
+        officialUrl: buildOfficialUrl('operator', 'bufferTime'),
+        sourceUrl: buildSourceUrl('operators/bufferTime.ts'),
+        guideUrl: buildGuideUrl('operators/transformation/bufferTime'),
     },
     'bufferCount': {
         name: 'bufferCount',
         category: 'transformation',
         description: 'Buffers specified number of values',
-        docUrl: `${DOC_BASE_URL}/operators/transformation/bufferCount`,
+        officialUrl: buildOfficialUrl('operator', 'bufferCount'),
+        sourceUrl: buildSourceUrl('operators/bufferCount.ts'),
+        guideUrl: buildGuideUrl('operators/transformation/bufferCount'),
     },
     'bufferWhen': {
         name: 'bufferWhen',
         category: 'transformation',
         description: 'Buffers values using closing selector',
-        docUrl: `${DOC_BASE_URL}/operators/transformation/bufferWhen`,
+        officialUrl: buildOfficialUrl('operator', 'bufferWhen'),
+        sourceUrl: buildSourceUrl('operators/bufferWhen.ts'),
+        guideUrl: buildGuideUrl('operators/transformation/bufferWhen'),
     },
     'bufferToggle': {
         name: 'bufferToggle',
         category: 'transformation',
         description: 'Buffers values based on opening and closing signals',
-        docUrl: `${DOC_BASE_URL}/operators/transformation/bufferToggle`,
+        officialUrl: buildOfficialUrl('operator', 'bufferToggle'),
+        sourceUrl: buildSourceUrl('operators/bufferToggle.ts'),
+        guideUrl: buildGuideUrl('operators/transformation/bufferToggle'),
     },
     'windowTime': {
         name: 'windowTime',
         category: 'transformation',
         description: 'Splits source into nested Observables by time',
-        docUrl: `${DOC_BASE_URL}/operators/transformation/windowTime`,
+        officialUrl: buildOfficialUrl('operator', 'windowTime'),
+        sourceUrl: buildSourceUrl('operators/windowTime.ts'),
+        guideUrl: buildGuideUrl('operators/transformation/windowTime'),
     },
     'window': {
         name: 'window',
         category: 'transformation',
         description: 'Splits source into nested Observable windows',
-        docUrl: `${DOC_BASE_URL}/operators/transformation/window`,
+        officialUrl: buildOfficialUrl('operator', 'window'),
+        sourceUrl: buildSourceUrl('operators/window.ts'),
+        guideUrl: buildGuideUrl('operators/transformation/window'),
     },
     'windowCount': {
         name: 'windowCount',
         category: 'transformation',
         description: 'Splits source into nested Observables by count',
-        docUrl: `${DOC_BASE_URL}/operators/transformation/windowCount`,
+        officialUrl: buildOfficialUrl('operator', 'windowCount'),
+        sourceUrl: buildSourceUrl('operators/windowCount.ts'),
+        guideUrl: buildGuideUrl('operators/transformation/windowCount'),
     },
     'windowToggle': {
         name: 'windowToggle',
         category: 'transformation',
         description: 'Splits source based on opening and closing signals',
-        docUrl: `${DOC_BASE_URL}/operators/transformation/windowToggle`,
+        officialUrl: buildOfficialUrl('operator', 'windowToggle'),
+        sourceUrl: buildSourceUrl('operators/windowToggle.ts'),
+        guideUrl: buildGuideUrl('operators/transformation/windowToggle'),
     },
     'windowWhen': {
         name: 'windowWhen',
         category: 'transformation',
         description: 'Splits source using closing selector',
-        docUrl: `${DOC_BASE_URL}/operators/transformation/windowWhen`,
+        officialUrl: buildOfficialUrl('operator', 'windowWhen'),
+        sourceUrl: buildSourceUrl('operators/windowWhen.ts'),
+        guideUrl: buildGuideUrl('operators/transformation/windowWhen'),
     },
     // Filtering operators
     'filter': {
         name: 'filter',
         category: 'filtering',
         description: 'Emits only values that pass a predicate test',
-        docUrl: `${DOC_BASE_URL}/operators/filtering/filter`,
+        officialUrl: buildOfficialUrl('operator', 'filter'),
+        sourceUrl: buildSourceUrl('operators/filter.ts'),
+        guideUrl: buildGuideUrl('operators/filtering/filter'),
     },
     'take': {
         name: 'take',
         category: 'filtering',
         description: 'Emits only the first n values, then completes',
-        docUrl: `${DOC_BASE_URL}/operators/filtering/take`,
+        officialUrl: buildOfficialUrl('operator', 'take'),
+        sourceUrl: buildSourceUrl('operators/take.ts'),
+        guideUrl: buildGuideUrl('operators/filtering/take'),
     },
     'takeLast': {
         name: 'takeLast',
         category: 'filtering',
         description: 'Emits only the last n values on completion',
-        docUrl: `${DOC_BASE_URL}/operators/filtering/takeLast`,
+        officialUrl: buildOfficialUrl('operator', 'takeLast'),
+        sourceUrl: buildSourceUrl('operators/takeLast.ts'),
+        guideUrl: buildGuideUrl('operators/filtering/takeLast'),
     },
     'takeWhile': {
         name: 'takeWhile',
         category: 'filtering',
         description: 'Emits while condition is true',
-        docUrl: `${DOC_BASE_URL}/operators/filtering/takeWhile`,
+        officialUrl: buildOfficialUrl('operator', 'takeWhile'),
+        sourceUrl: buildSourceUrl('operators/takeWhile.ts'),
+        guideUrl: buildGuideUrl('operators/filtering/takeWhile'),
     },
     'skip': {
         name: 'skip',
         category: 'filtering',
         description: 'Skips the first n emissions',
-        docUrl: `${DOC_BASE_URL}/operators/filtering/skip`,
+        officialUrl: buildOfficialUrl('operator', 'skip'),
+        sourceUrl: buildSourceUrl('operators/skip.ts'),
+        guideUrl: buildGuideUrl('operators/filtering/skip'),
     },
     'skipLast': {
         name: 'skipLast',
         category: 'filtering',
         description: 'Skips the last n emissions',
-        docUrl: `${DOC_BASE_URL}/operators/filtering/skipLast`,
+        officialUrl: buildOfficialUrl('operator', 'skipLast'),
+        sourceUrl: buildSourceUrl('operators/skipLast.ts'),
+        guideUrl: buildGuideUrl('operators/filtering/skipLast'),
     },
     'skipWhile': {
         name: 'skipWhile',
         category: 'filtering',
         description: 'Skips while condition is true',
-        docUrl: `${DOC_BASE_URL}/operators/filtering/skipWhile`,
+        officialUrl: buildOfficialUrl('operator', 'skipWhile'),
+        sourceUrl: buildSourceUrl('operators/skipWhile.ts'),
+        guideUrl: buildGuideUrl('operators/filtering/skipWhile'),
     },
     'skipUntil': {
         name: 'skipUntil',
         category: 'filtering',
         description: 'Skips until another Observable emits',
-        docUrl: `${DOC_BASE_URL}/operators/filtering/skipUntil`,
+        officialUrl: buildOfficialUrl('operator', 'skipUntil'),
+        sourceUrl: buildSourceUrl('operators/skipUntil.ts'),
+        guideUrl: buildGuideUrl('operators/filtering/skipUntil'),
     },
     'first': {
         name: 'first',
         category: 'filtering',
         description: 'Emits only the first value (or first matching)',
-        docUrl: `${DOC_BASE_URL}/operators/filtering/first`,
+        officialUrl: buildOfficialUrl('operator', 'first'),
+        sourceUrl: buildSourceUrl('operators/first.ts'),
+        guideUrl: buildGuideUrl('operators/filtering/first'),
     },
     'last': {
         name: 'last',
         category: 'filtering',
         description: 'Emits only the last value (or last matching)',
-        docUrl: `${DOC_BASE_URL}/operators/filtering/last`,
+        officialUrl: buildOfficialUrl('operator', 'last'),
+        sourceUrl: buildSourceUrl('operators/last.ts'),
+        guideUrl: buildGuideUrl('operators/filtering/last'),
     },
     'elementAt': {
         name: 'elementAt',
         category: 'filtering',
         description: 'Emits only the value at specified index',
-        docUrl: `${DOC_BASE_URL}/operators/filtering/elementAt`,
+        officialUrl: buildOfficialUrl('operator', 'elementAt'),
+        sourceUrl: buildSourceUrl('operators/elementAt.ts'),
+        guideUrl: buildGuideUrl('operators/filtering/elementAt'),
     },
     'find': {
         name: 'find',
         category: 'filtering',
         description: 'Emits first value that matches predicate',
-        docUrl: `${DOC_BASE_URL}/operators/filtering/find`,
+        officialUrl: buildOfficialUrl('operator', 'find'),
+        sourceUrl: buildSourceUrl('operators/find.ts'),
+        guideUrl: buildGuideUrl('operators/filtering/find'),
     },
     'findIndex': {
         name: 'findIndex',
         category: 'filtering',
         description: 'Emits index of first value that matches',
-        docUrl: `${DOC_BASE_URL}/operators/filtering/findIndex`,
+        officialUrl: buildOfficialUrl('operator', 'findIndex'),
+        sourceUrl: buildSourceUrl('operators/findIndex.ts'),
+        guideUrl: buildGuideUrl('operators/filtering/findIndex'),
     },
     'debounceTime': {
         name: 'debounceTime',
         category: 'filtering',
         description: 'Emits after a period of inactivity',
-        docUrl: `${DOC_BASE_URL}/operators/filtering/debounceTime`,
+        officialUrl: buildOfficialUrl('operator', 'debounceTime'),
+        sourceUrl: buildSourceUrl('operators/debounceTime.ts'),
+        guideUrl: buildGuideUrl('operators/filtering/debounceTime'),
     },
     'throttleTime': {
         name: 'throttleTime',
         category: 'filtering',
         description: 'Emits first value, then ignores for duration',
-        docUrl: `${DOC_BASE_URL}/operators/filtering/throttleTime`,
+        officialUrl: buildOfficialUrl('operator', 'throttleTime'),
+        sourceUrl: buildSourceUrl('operators/throttleTime.ts'),
+        guideUrl: buildGuideUrl('operators/filtering/throttleTime'),
     },
     'auditTime': {
         name: 'auditTime',
         category: 'filtering',
         description: 'Emits most recent value after duration',
-        docUrl: `${DOC_BASE_URL}/operators/filtering/auditTime`,
+        officialUrl: buildOfficialUrl('operator', 'auditTime'),
+        sourceUrl: buildSourceUrl('operators/auditTime.ts'),
+        guideUrl: buildGuideUrl('operators/filtering/auditTime'),
     },
     'audit': {
         name: 'audit',
         category: 'filtering',
         description: 'Emits most recent value when notifier emits',
-        docUrl: `${DOC_BASE_URL}/operators/filtering/audit`,
+        officialUrl: buildOfficialUrl('operator', 'audit'),
+        sourceUrl: buildSourceUrl('operators/audit.ts'),
+        guideUrl: buildGuideUrl('operators/filtering/audit'),
     },
     'sampleTime': {
         name: 'sampleTime',
         category: 'filtering',
         description: 'Emits most recent value at intervals',
-        docUrl: `${DOC_BASE_URL}/operators/filtering/sampleTime`,
+        officialUrl: buildOfficialUrl('operator', 'sampleTime'),
+        sourceUrl: buildSourceUrl('operators/sampleTime.ts'),
+        guideUrl: buildGuideUrl('operators/filtering/sampleTime'),
     },
     'ignoreElements': {
         name: 'ignoreElements',
         category: 'filtering',
         description: 'Ignores all emissions, only passes complete/error',
-        docUrl: `${DOC_BASE_URL}/operators/filtering/ignoreElements`,
+        officialUrl: buildOfficialUrl('operator', 'ignoreElements'),
+        sourceUrl: buildSourceUrl('operators/ignoreElements.ts'),
+        guideUrl: buildGuideUrl('operators/filtering/ignoreElements'),
     },
     'distinct': {
         name: 'distinct',
         category: 'filtering',
         description: 'Emits only distinct values',
-        docUrl: `${DOC_BASE_URL}/operators/filtering/distinct`,
+        officialUrl: buildOfficialUrl('operator', 'distinct'),
+        sourceUrl: buildSourceUrl('operators/distinct.ts'),
+        guideUrl: buildGuideUrl('operators/filtering/distinct'),
     },
     'distinctUntilChanged': {
         name: 'distinctUntilChanged',
         category: 'filtering',
         description: 'Emits when value changes from previous',
-        docUrl: `${DOC_BASE_URL}/operators/filtering/distinctUntilChanged`,
+        officialUrl: buildOfficialUrl('operator', 'distinctUntilChanged'),
+        sourceUrl: buildSourceUrl('operators/distinctUntilChanged.ts'),
+        guideUrl: buildGuideUrl('operators/filtering/distinctUntilChanged'),
     },
     'distinctUntilKeyChanged': {
         name: 'distinctUntilKeyChanged',
         category: 'filtering',
         description: 'Emits when specific key value changes',
-        docUrl: `${DOC_BASE_URL}/operators/filtering/distinctUntilKeyChanged`,
+        officialUrl: buildOfficialUrl('operator', 'distinctUntilKeyChanged'),
+        sourceUrl: buildSourceUrl('operators/distinctUntilKeyChanged.ts'),
+        guideUrl: buildGuideUrl('operators/filtering/distinctUntilKeyChanged'),
     },
     // Combination operators (pipeable)
     'concatWith': {
         name: 'concatWith',
         category: 'combination',
         description: 'Concatenates with other Observables in sequence',
-        docUrl: `${DOC_BASE_URL}/operators/combination/concatWith`,
+        officialUrl: buildOfficialUrl('operator', 'concatWith'),
+        sourceUrl: buildSourceUrl('operators/concatWith.ts'),
+        guideUrl: buildGuideUrl('operators/combination/concatWith'),
     },
     'mergeWith': {
         name: 'mergeWith',
         category: 'combination',
         description: 'Merges with other Observables concurrently',
-        docUrl: `${DOC_BASE_URL}/operators/combination/mergeWith`,
+        officialUrl: buildOfficialUrl('operator', 'mergeWith'),
+        sourceUrl: buildSourceUrl('operators/mergeWith.ts'),
+        guideUrl: buildGuideUrl('operators/combination/mergeWith'),
     },
     'combineLatestWith': {
         name: 'combineLatestWith',
         category: 'combination',
         description: 'Combines latest values with other Observables',
-        docUrl: `${DOC_BASE_URL}/operators/combination/combineLatestWith`,
+        officialUrl: buildOfficialUrl('operator', 'combineLatestWith'),
+        sourceUrl: buildSourceUrl('operators/combineLatestWith.ts'),
+        guideUrl: buildGuideUrl('operators/combination/combineLatestWith'),
     },
     'zipWith': {
         name: 'zipWith',
         category: 'combination',
         description: 'Zips with other Observables by index',
-        docUrl: `${DOC_BASE_URL}/operators/combination/zipWith`,
+        officialUrl: buildOfficialUrl('operator', 'zipWith'),
+        sourceUrl: buildSourceUrl('operators/zipWith.ts'),
+        guideUrl: buildGuideUrl('operators/combination/zipWith'),
     },
     'raceWith': {
         name: 'raceWith',
         category: 'combination',
         description: 'Races with other Observables, first wins',
-        docUrl: `${DOC_BASE_URL}/operators/combination/raceWith`,
+        officialUrl: buildOfficialUrl('operator', 'raceWith'),
+        sourceUrl: buildSourceUrl('operators/raceWith.ts'),
+        guideUrl: buildGuideUrl('operators/combination/raceWith'),
     },
     'withLatestFrom': {
         name: 'withLatestFrom',
         category: 'combination',
         description: 'Combines with latest value from another Observable',
-        docUrl: `${DOC_BASE_URL}/operators/combination/withLatestFrom`,
+        officialUrl: buildOfficialUrl('operator', 'withLatestFrom'),
+        sourceUrl: buildSourceUrl('operators/withLatestFrom.ts'),
+        guideUrl: buildGuideUrl('operators/combination/withLatestFrom'),
     },
     'mergeAll': {
         name: 'mergeAll',
         category: 'combination',
         description: 'Flattens higher-order Observable concurrently',
-        docUrl: `${DOC_BASE_URL}/operators/combination/mergeAll`,
+        officialUrl: buildOfficialUrl('operator', 'mergeAll'),
+        sourceUrl: buildSourceUrl('operators/mergeAll.ts'),
+        guideUrl: buildGuideUrl('operators/combination/mergeAll'),
     },
     'concatAll': {
         name: 'concatAll',
         category: 'combination',
         description: 'Flattens higher-order Observable in sequence',
-        docUrl: `${DOC_BASE_URL}/operators/combination/concatAll`,
+        officialUrl: buildOfficialUrl('operator', 'concatAll'),
+        sourceUrl: buildSourceUrl('operators/concatAll.ts'),
+        guideUrl: buildGuideUrl('operators/combination/concatAll'),
     },
     'switchAll': {
         name: 'switchAll',
         category: 'combination',
         description: 'Flattens to latest inner Observable',
-        docUrl: `${DOC_BASE_URL}/operators/combination/switchAll`,
+        officialUrl: buildOfficialUrl('operator', 'switchAll'),
+        sourceUrl: buildSourceUrl('operators/switchAll.ts'),
+        guideUrl: buildGuideUrl('operators/combination/switchAll'),
     },
     'exhaustAll': {
         name: 'exhaustAll',
         category: 'combination',
         description: 'Flattens, ignoring new while active',
-        docUrl: `${DOC_BASE_URL}/operators/combination/exhaustAll`,
+        officialUrl: buildOfficialUrl('operator', 'exhaustAll'),
+        sourceUrl: buildSourceUrl('operators/exhaustAll.ts'),
+        guideUrl: buildGuideUrl('operators/combination/exhaustAll'),
     },
     'combineLatestAll': {
         name: 'combineLatestAll',
         category: 'combination',
         description: 'Flattens with combineLatest strategy',
-        docUrl: `${DOC_BASE_URL}/operators/combination/combineLatestAll`,
+        officialUrl: buildOfficialUrl('operator', 'combineLatestAll'),
+        sourceUrl: buildSourceUrl('operators/combineLatestAll.ts'),
+        guideUrl: buildGuideUrl('operators/combination/combineLatestAll'),
     },
     'zipAll': {
         name: 'zipAll',
         category: 'combination',
         description: 'Flattens with zip strategy',
-        docUrl: `${DOC_BASE_URL}/operators/combination/zipAll`,
+        officialUrl: buildOfficialUrl('operator', 'zipAll'),
+        sourceUrl: buildSourceUrl('operators/zipAll.ts'),
+        guideUrl: buildGuideUrl('operators/combination/zipAll'),
     },
     // Utility operators
     'tap': {
         name: 'tap',
         category: 'utility',
         description: 'Performs side effects without altering emissions',
-        docUrl: `${DOC_BASE_URL}/operators/utility/tap`,
+        officialUrl: buildOfficialUrl('operator', 'tap'),
+        sourceUrl: buildSourceUrl('operators/tap.ts'),
+        guideUrl: buildGuideUrl('operators/utility/tap'),
     },
     'delay': {
         name: 'delay',
         category: 'utility',
         description: 'Delays emissions by specified time',
-        docUrl: `${DOC_BASE_URL}/operators/utility/delay`,
+        officialUrl: buildOfficialUrl('operator', 'delay'),
+        sourceUrl: buildSourceUrl('operators/delay.ts'),
+        guideUrl: buildGuideUrl('operators/utility/delay'),
     },
     'delayWhen': {
         name: 'delayWhen',
         category: 'utility',
         description: 'Delays emissions based on another Observable',
-        docUrl: `${DOC_BASE_URL}/operators/utility/delayWhen`,
+        officialUrl: buildOfficialUrl('operator', 'delayWhen'),
+        sourceUrl: buildSourceUrl('operators/delayWhen.ts'),
+        guideUrl: buildGuideUrl('operators/utility/delayWhen'),
     },
     'timeout': {
         name: 'timeout',
         category: 'utility',
         description: 'Errors if no emission within specified time',
-        docUrl: `${DOC_BASE_URL}/operators/utility/timeout`,
+        officialUrl: buildOfficialUrl('operator', 'timeout'),
+        sourceUrl: buildSourceUrl('operators/timeout.ts'),
+        guideUrl: buildGuideUrl('operators/utility/timeout'),
     },
     'takeUntil': {
         name: 'takeUntil',
         category: 'utility',
         description: 'Emits until another Observable emits',
-        docUrl: `${DOC_BASE_URL}/operators/utility/takeUntil`,
+        officialUrl: buildOfficialUrl('operator', 'takeUntil'),
+        sourceUrl: buildSourceUrl('operators/takeUntil.ts'),
+        guideUrl: buildGuideUrl('operators/utility/takeUntil'),
     },
     'finalize': {
         name: 'finalize',
         category: 'utility',
         description: 'Executes callback on completion or error',
-        docUrl: `${DOC_BASE_URL}/operators/utility/finalize`,
+        officialUrl: buildOfficialUrl('operator', 'finalize'),
+        sourceUrl: buildSourceUrl('operators/finalize.ts'),
+        guideUrl: buildGuideUrl('operators/utility/finalize'),
     },
     'repeat': {
         name: 'repeat',
         category: 'utility',
         description: 'Resubscribes to source on completion',
-        docUrl: `${DOC_BASE_URL}/operators/utility/repeat`,
+        officialUrl: buildOfficialUrl('operator', 'repeat'),
+        sourceUrl: buildSourceUrl('operators/repeat.ts'),
+        guideUrl: buildGuideUrl('operators/utility/repeat'),
     },
     'startWith': {
         name: 'startWith',
         category: 'utility',
         description: 'Emits specified values before source emissions',
-        docUrl: `${DOC_BASE_URL}/operators/utility/startWith`,
+        officialUrl: buildOfficialUrl('operator', 'startWith'),
+        sourceUrl: buildSourceUrl('operators/startWith.ts'),
+        guideUrl: buildGuideUrl('operators/utility/startWith'),
     },
     'endWith': {
         name: 'endWith',
         category: 'utility',
         description: 'Emits specified values after source completes',
-        docUrl: `${DOC_BASE_URL}/operators/utility/endWith`,
+        officialUrl: buildOfficialUrl('operator', 'endWith'),
+        sourceUrl: buildSourceUrl('operators/endWith.ts'),
     },
     'toArray': {
         name: 'toArray',
         category: 'utility',
         description: 'Collects all emissions into an array',
-        docUrl: `${DOC_BASE_URL}/operators/utility/toArray`,
+        officialUrl: buildOfficialUrl('operator', 'toArray'),
+        sourceUrl: buildSourceUrl('operators/toArray.ts'),
+        guideUrl: buildGuideUrl('operators/utility/toArray'),
     },
     'materialize': {
         name: 'materialize',
         category: 'utility',
         description: 'Converts emissions to Notification objects',
-        docUrl: `${DOC_BASE_URL}/operators/utility/materialize`,
+        officialUrl: buildOfficialUrl('operator', 'materialize'),
+        sourceUrl: buildSourceUrl('operators/materialize.ts'),
+        guideUrl: buildGuideUrl('operators/utility/materialize'),
     },
     'dematerialize': {
         name: 'dematerialize',
         category: 'utility',
         description: 'Converts Notification objects to emissions',
-        docUrl: `${DOC_BASE_URL}/operators/utility/dematerialize`,
+        officialUrl: buildOfficialUrl('operator', 'dematerialize'),
+        sourceUrl: buildSourceUrl('operators/dematerialize.ts'),
+        guideUrl: buildGuideUrl('operators/utility/dematerialize'),
     },
     'observeOn': {
         name: 'observeOn',
         category: 'utility',
         description: 'Re-emits values on specified scheduler',
-        docUrl: `${DOC_BASE_URL}/operators/utility/observeOn`,
+        officialUrl: buildOfficialUrl('operator', 'observeOn'),
+        sourceUrl: buildSourceUrl('operators/observeOn.ts'),
+        guideUrl: buildGuideUrl('operators/utility/observeOn'),
     },
     'subscribeOn': {
         name: 'subscribeOn',
         category: 'utility',
         description: 'Subscribes on specified scheduler',
-        docUrl: `${DOC_BASE_URL}/operators/utility/subscribeOn`,
+        officialUrl: buildOfficialUrl('operator', 'subscribeOn'),
+        sourceUrl: buildSourceUrl('operators/subscribeOn.ts'),
+        guideUrl: buildGuideUrl('operators/utility/subscribeOn'),
     },
     'timestamp': {
         name: 'timestamp',
         category: 'utility',
         description: 'Attaches timestamp to each emission',
-        docUrl: `${DOC_BASE_URL}/operators/utility/timestamp`,
+        officialUrl: buildOfficialUrl('operator', 'timestamp'),
+        sourceUrl: buildSourceUrl('operators/timestamp.ts'),
+        guideUrl: buildGuideUrl('operators/utility/timestamp'),
     },
     // Conditional operators
     'defaultIfEmpty': {
         name: 'defaultIfEmpty',
         category: 'conditional',
         description: 'Emits default value if source completes empty',
-        docUrl: `${DOC_BASE_URL}/operators/conditional/defaultIfEmpty`,
+        officialUrl: buildOfficialUrl('operator', 'defaultIfEmpty'),
+        sourceUrl: buildSourceUrl('operators/defaultIfEmpty.ts'),
+        guideUrl: buildGuideUrl('operators/conditional/defaultIfEmpty'),
     },
     'every': {
         name: 'every',
         category: 'conditional',
         description: 'Emits true if all values pass predicate',
-        docUrl: `${DOC_BASE_URL}/operators/conditional/every`,
+        officialUrl: buildOfficialUrl('operator', 'every'),
+        sourceUrl: buildSourceUrl('operators/every.ts'),
+        guideUrl: buildGuideUrl('operators/conditional/every'),
     },
     'isEmpty': {
         name: 'isEmpty',
         category: 'conditional',
         description: 'Emits true if source completes without emitting',
-        docUrl: `${DOC_BASE_URL}/operators/conditional/isEmpty`,
+        officialUrl: buildOfficialUrl('operator', 'isEmpty'),
+        sourceUrl: buildSourceUrl('operators/isEmpty.ts'),
+        guideUrl: buildGuideUrl('operators/conditional/isEmpty'),
     },
     // Error handling operators
     'catchError': {
         name: 'catchError',
         category: 'error-handling',
         description: 'Catches errors and returns new Observable',
-        docUrl: `${DOC_BASE_URL}/operators/error-handling/catchError`,
+        officialUrl: buildOfficialUrl('operator', 'catchError'),
+        sourceUrl: buildSourceUrl('operators/catchError.ts'),
     },
     'retry': {
         name: 'retry',
         category: 'error-handling',
         description: 'Retries the source Observable on error',
-        docUrl: `${DOC_BASE_URL}/operators/error-handling/retry`,
+        officialUrl: buildOfficialUrl('operator', 'retry'),
+        sourceUrl: buildSourceUrl('operators/retry.ts'),
     },
     'retryWhen': {
         name: 'retryWhen',
         category: 'error-handling',
         description: 'Retries based on custom logic',
-        docUrl: `${DOC_BASE_URL}/operators/error-handling/retryWhen`,
+        officialUrl: buildOfficialUrl('operator', 'retryWhen'),
+        sourceUrl: buildSourceUrl('operators/retryWhen.ts'),
+        deprecation: { deprecated: true, since: '7.3.0', replacement: 'retry({ delay: (error, retryCount) => ... })' },
     },
     // Multicasting operators
     'share': {
         name: 'share',
         category: 'multicasting',
         description: 'Shares a single subscription among observers',
-        docUrl: `${DOC_BASE_URL}/operators/multicasting/share`,
+        officialUrl: buildOfficialUrl('operator', 'share'),
+        sourceUrl: buildSourceUrl('operators/share.ts'),
+        guideUrl: buildGuideUrl('operators/multicasting/share'),
     },
     'shareReplay': {
         name: 'shareReplay',
         category: 'multicasting',
         description: 'Shares and replays specified emissions',
-        docUrl: `${DOC_BASE_URL}/operators/multicasting/shareReplay`,
+        officialUrl: buildOfficialUrl('operator', 'shareReplay'),
+        sourceUrl: buildSourceUrl('operators/shareReplay.ts'),
+        guideUrl: buildGuideUrl('operators/multicasting/shareReplay'),
     },
     // Legacy/deprecated but still commonly used
     'pluck': {
         name: 'pluck',
         category: 'transformation',
         description: 'Plucks a nested property from emitted objects (deprecated: use map)',
-        docUrl: `${DOC_BASE_URL}/operators/transformation/pluck`,
+        officialUrl: buildOfficialUrl('operator', 'pluck'),
+        sourceUrl: buildSourceUrl('operators/pluck.ts'),
+        deprecation: { deprecated: true, since: '7.2.0', replacement: 'map(obj => obj.prop)' },
     },
     'mapTo': {
         name: 'mapTo',
         category: 'transformation',
         description: 'Maps every emission to a constant value (deprecated: use map)',
-        docUrl: `${DOC_BASE_URL}/operators/transformation/mapTo`,
+        officialUrl: buildOfficialUrl('operator', 'mapTo'),
+        sourceUrl: buildSourceUrl('operators/mapTo.ts'),
+        deprecation: { deprecated: true, since: '7.2.0', replacement: 'map(() => value)' },
     },
 };
 //# sourceMappingURL=operators.js.map