Moment Extensions

/**
 * Extend a Moment.js instance with range functionality
 * @param moment - Moment.js constructor to extend
 * @returns Extended moment with range methods and DateRange constructor
 */
function extendMoment(moment: typeof moment): MomentRange;

interface MomentRange extends typeof moment {
  // All original moment functionality plus:
  range: typeof moment.range;
  rangeFromInterval: typeof moment.rangeFromInterval;
  rangeFromISOString: typeof moment.rangeFromISOString;
  isRange: typeof moment.isRange;
}

import Moment from 'moment';
import { extendMoment } from 'moment-range';

// Extend moment with range functionality
const moment = extendMoment(Moment);

// Now moment has range methods
const range = moment.range('2024-01-01', '2024-01-31');
console.log(moment.isRange(range)); // true

// CommonJS usage
const Moment = require('moment');
const MomentRange = require('moment-range');
const moment = MomentRange.extendMoment(Moment);

/**
 * Create a DateRange from various inputs
 * Added to moment static object by extendMoment
 */
moment.range(start: Date | Moment, end: Date | Moment): DateRange;
moment.range(range: [Date | Moment, Date | Moment]): DateRange;
moment.range(isoString: string): DateRange;
moment.range(interval: string): DateRange; // For current moment

/**
 * Create range from interval calculation
 */
moment.rangeFromInterval(interval: string, count?: number, date?: Moment): DateRange;

/**
 * Create range from ISO string with timezone preservation
 */
moment.rangeFromISOString(isoTimeInterval: string): DateRange;

/**
 * DEPRECATED: Alias for rangeFromISOString
 */
moment.parseZoneRange(isoTimeInterval: string): DateRange;

const moment = extendMoment(Moment);

// All range creation methods now available on moment
const range1 = moment.range('2024-01-01', '2024-01-31');
const range2 = moment.rangeFromInterval('day', 7);
const range3 = moment.rangeFromISOString('2024-01-01T00:00:00Z/2024-01-31T23:59:59Z');

// Create range for current year
const thisYear = moment().range('year');

/**
 * Create a DateRange from this moment instance
 * Added to moment prototype by extendMoment
 * @param start - Optional start date (uses this moment if not provided)
 * @param end - Optional end date
 * @returns DateRange instance
 */
moment.fn.range(start?: Date | Moment, end?: Date | Moment): DateRange;

// Overloaded for interval usage
moment.fn.range(interval: string): DateRange;

const moment = extendMoment(Moment);

// Create range from current moment
const now = moment();
const rangeFromNow = now.range(null, moment().add(1, 'week'));

// Create range for current day
const today = moment().range('day');

// Create range using current moment as start
const nextMonth = moment().range(moment(), moment().add(1, 'month'));

/**
 * Check if an object is a DateRange instance
 * Added to moment static object by extendMoment
 * @param range - Object to test
 * @returns true if object is a DateRange
 */
moment.isRange(range: any): boolean;

const moment = extendMoment(Moment);

const range = moment.range('2024-01-01', '2024-01-31');
const notRange = moment();
const fakeRange = { start: moment(), end: moment() };

console.log(moment.isRange(range));     // true
console.log(moment.isRange(notRange));  // false
console.log(moment.isRange(fakeRange)); // false
console.log(moment.isRange(null));      // false
console.log(moment.isRange(undefined)); // false

/**
 * Check if this moment is within the given DateRange
 * Added to moment prototype by extendMoment
 * @param range - DateRange to test against
 * @returns true if this moment is contained in the range
 */
moment.fn.within(range: DateRange): boolean;

const moment = extendMoment(Moment);

const range = moment.range('2024-01-01', '2024-01-31');

// Test various moments
const jan15 = moment('2024-01-15');
const feb15 = moment('2024-02-15');
const jan01 = moment('2024-01-01'); // boundary
const jan31 = moment('2024-01-31'); // boundary

console.log(jan15.within(range)); // true
console.log(feb15.within(range)); // false
console.log(jan01.within(range)); // true (boundaries included)
console.log(jan31.within(range)); // true (boundaries included)

// Works with open-ended ranges
const openRange = moment.range(null, '2024-01-31');
const earlyDate = moment('2020-01-01');
console.log(earlyDate.within(openRange)); // true

/**
 * Reference to DateRange constructor
 * Added to moment.range by extendMoment
 */
moment.range.constructor: typeof DateRange;

const moment = extendMoment(Moment);

// Access DateRange constructor
const DateRangeClass = moment.range.constructor;
const range = new DateRangeClass('2024-01-01', '2024-01-31');

// Useful for type checking
console.log(range instanceof DateRangeClass); // true
console.log(range instanceof moment.range.constructor); // true

// Plugin pattern - extend existing moment instance
import moment from 'moment'; // Your existing moment
import { extendMoment } from 'moment-range';

// Extend without replacing
const momentRange = extendMoment(moment);

// Factory pattern - create extended instance on demand
function createMomentWithRanges() {
  return extendMoment(require('moment'));
}

// Namespace pattern - keep ranges separate
import Moment from 'moment';
import { extendMoment, DateRange } from 'moment-range';

const moment = extendMoment(Moment);

export { moment, DateRange };

// Conditional extension - only extend if needed
let extendedMoment = null;
function getMomentWithRanges() {
  if (!extendedMoment) {
    extendedMoment = extendMoment(require('moment'));
  }
  return extendedMoment;
}

<!-- Load dependencies -->
<script src="moment.js"></script>
<script src="moment-range.js"></script>

<script>
  // Browser global usage
  const momentRange = window['moment-range'];
  momentRange.extendMoment(moment);
  
  // Now moment has range functionality
  const range = moment.range('2024-01-01', '2024-01-31');
  console.log(moment.isRange(range)); // true
</script>

// AMD/RequireJS usage
define(['moment', 'moment-range'], function(moment, momentRange) {
  const extendedMoment = momentRange.extendMoment(moment);
  return extendedMoment;
});

// UMD detection
if (typeof module !== 'undefined' && module.exports) {
  // Node.js
  module.exports = extendMoment(require('moment'));
} else if (typeof define === 'function' && define.amd) {
  // AMD
  define(['moment'], function(moment) {
    return extendMoment(moment);
  });
} else {
  // Browser globals
  window.moment = extendMoment(window.moment);
}

// Extended moment interface
interface MomentRange extends typeof moment {
  range: {
    (start: Date | Moment, end: Date | Moment): DateRange;
    (range: [Date | Moment, Date | Moment]): DateRange;
    (isoString: string): DateRange;
    (interval: string): DateRange;
    constructor: typeof DateRange;
  };
  rangeFromInterval(interval: string, count?: number, date?: Moment): DateRange;
  rangeFromISOString(isoTimeInterval: string): DateRange;
  parseZoneRange(isoTimeInterval: string): DateRange; // DEPRECATED
  isRange(range: any): boolean;
}

// Extended moment instance interface
declare module 'moment' {
  interface Moment {
    within(range: DateRange): boolean;
    range(start?: Date | Moment, end?: Date | Moment): DateRange;
    range(interval: string): DateRange;
  }
}