feat(planning): grille hebdomadaire complète avec API et filtres

- Connexion API via proxy Angular (résolution CORS, base path /api)
- Import CSS ng-zorro global pour les modales et composants
- Filtres Camion/Show câblés sur l'affichage de la grille
- Camions affichés via TrucksService (linkés au show du même créneau)
- Panneau de détails : spectacles + camions du jour sélectionné
- Modale de création de spectacle stylisée avec fond et centrage
- Positionnement précis des events à la minute dans leur créneau
- Auto-scroll vers l'heure courante au chargement
- Ligne "maintenant" sur la colonne du jour actuel
- Régénération des services OpenAPI (nouveaux noms de types)

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

node_modules/body-parser/lib/read.js

@@ -16,8 +16,6 @@ var getBody = require('raw-body')
 var iconv = require('iconv-lite')
 var onFinished = require('on-finished')
 var zlib = require('node:zlib')
-var hasBody = require('type-is').hasBody
-var { getCharset } = require('./utils')
 
 /**
  * Module exports.
@@ -28,61 +26,24 @@ module.exports = read
 /**
  * Read a request into a buffer and parse.
  *
- * @param {Object} req
- * @param {Object} res
- * @param {Function} next
- * @param {Function} parse
- * @param {Function} debug
- * @param {Object} options
+ * @param {object} req
+ * @param {object} res
+ * @param {function} next
+ * @param {function} parse
+ * @param {function} debug
+ * @param {object} options
  * @private
  */
+
 function read (req, res, next, parse, debug, options) {
-  if (onFinished.isFinished(req)) {
-    debug('body already parsed')
-    next()
-    return
-  }
-
-  if (!('body' in req)) {
-    req.body = undefined
-  }
-
-  // skip requests without bodies
-  if (!hasBody(req)) {
-    debug('skip empty body')
-    next()
-    return
-  }
-
-  debug('content-type %j', req.headers['content-type'])
-
-  // determine if request should be parsed
-  if (!options.shouldParse(req)) {
-    debug('skip parsing')
-    next()
-    return
-  }
-
-  var encoding = null
-  if (options?.skipCharset !== true) {
-    encoding = getCharset(req) || options.defaultCharset
-
-    // validate charset
-    if (!!options?.isValidCharset && !options.isValidCharset(encoding)) {
-      debug('invalid charset')
-      next(createError(415, 'unsupported charset "' + encoding.toUpperCase() + '"', {
-        charset: encoding,
-        type: 'charset.unsupported'
-      }))
-      return
-    }
-  }
-
   var length
   var opts = options
   var stream
 
   // read options
+  var encoding = opts.encoding !== null
+    ? opts.encoding
+    : null
   var verify = opts.verify
 
   try {
@@ -175,12 +136,13 @@ function read (req, res, next, parse, debug, options) {
 /**
  * Get the content stream of the request.
  *
- * @param {Object} req
- * @param {Function} debug
- * @param {boolean} inflate
- * @returns {Object}
- * @private
+ * @param {object} req
+ * @param {function} debug
+ * @param {boolean} [inflate=true]
+ * @return {object}
+ * @api private
  */
+
 function contentstream (req, debug, inflate) {
   var encoding = (req.headers['content-encoding'] || 'identity').toLowerCase()
   var length = req.headers['content-length']
@@ -207,9 +169,9 @@ function contentstream (req, debug, inflate) {
 /**
  * Create a decompression stream for the given encoding.
  * @param {string} encoding
- * @param {Function} debug
- * @returns {Object}
- * @private
+ * @param {function} debug
+ * @return {object}
+ * @api private
  */
 function createDecompressionStream (encoding, debug) {
   switch (encoding) {
@@ -233,10 +195,11 @@ function createDecompressionStream (encoding, debug) {
 /**
  * Dump the contents of a request.
  *
- * @param {Object} req
- * @param {Function} callback
- * @private
+ * @param {object} req
+ * @param {function} callback
+ * @api private
  */
+
 function dump (req, callback) {
   if (onFinished.isFinished(req)) {
     callback(null)

node_modules/body-parser/lib/types/json.js

@@ -12,9 +12,12 @@
  * @private
  */
 
+var createError = require('http-errors')
 var debug = require('debug')('body-parser:json')
+var isFinished = require('on-finished').isFinished
 var read = require('../read')
-var { normalizeOptions } = require('../utils')
+var typeis = require('type-is')
+var { getCharset, normalizeOptions } = require('../utils')
 
 /**
  * Module exports.
@@ -33,6 +36,7 @@ module.exports = json
  *            %x0A /              ; Line feed or New line
  *            %x0D )              ; Carriage return
  */
+
 var FIRST_CHAR_REGEXP = /^[\x20\x09\x0a\x0d]*([^\x20\x09\x0a\x0d])/ // eslint-disable-line no-control-regex
 
 var JSON_SYNTAX_CHAR = '#'
@@ -41,12 +45,13 @@ var JSON_SYNTAX_REGEXP = /#+/g
 /**
  * Create a middleware to parse JSON bodies.
  *
- * @param {Object} [options]
- * @returns {Function}
+ * @param {object} [options]
+ * @return {function}
  * @public
  */
+
 function json (options) {
-  const normalizedOptions = normalizeOptions(options, 'application/json')
+  var { inflate, limit, verify, shouldParse } = normalizeOptions(options, 'application/json')
 
   var reviver = options?.reviver
   var strict = options?.strict !== false
@@ -78,14 +83,51 @@ function json (options) {
     }
   }
 
-  const readOptions = {
-    ...normalizedOptions,
-    // assert charset per RFC 7159 sec 8.1
-    isValidCharset: (charset) => charset.slice(0, 4) === 'utf-'
-  }
-
   return function jsonParser (req, res, next) {
-    read(req, res, next, parse, debug, readOptions)
+    if (isFinished(req)) {
+      debug('body already parsed')
+      next()
+      return
+    }
+
+    if (!('body' in req)) {
+      req.body = undefined
+    }
+
+    // skip requests without bodies
+    if (!typeis.hasBody(req)) {
+      debug('skip empty body')
+      next()
+      return
+    }
+
+    debug('content-type %j', req.headers['content-type'])
+
+    // determine if request should be parsed
+    if (!shouldParse(req)) {
+      debug('skip parsing')
+      next()
+      return
+    }
+
+    // assert charset per RFC 7159 sec 8.1
+    var charset = getCharset(req) || 'utf-8'
+    if (charset.slice(0, 4) !== 'utf-') {
+      debug('invalid charset')
+      next(createError(415, 'unsupported charset "' + charset.toUpperCase() + '"', {
+        charset: charset,
+        type: 'charset.unsupported'
+      }))
+      return
+    }
+
+    // read
+    read(req, res, next, parse, debug, {
+      encoding: charset,
+      inflate,
+      limit,
+      verify
+    })
   }
 }
 
@@ -94,15 +136,20 @@ function json (options) {
  *
  * @param {string} str
  * @param {string} char
- * @returns {Error}
+ * @return {Error}
  * @private
  */
+
 function createStrictSyntaxError (str, char) {
   var index = str.indexOf(char)
   var partial = ''
 
   if (index !== -1) {
-    partial = str.substring(0, index) + JSON_SYNTAX_CHAR.repeat(str.length - index)
+    partial = str.substring(0, index) + JSON_SYNTAX_CHAR
+
+    for (var i = index + 1; i < str.length; i++) {
+      partial += JSON_SYNTAX_CHAR
+    }
   }
 
   try {
@@ -121,9 +168,10 @@ function createStrictSyntaxError (str, char) {
  * Get the first non-whitespace character in a string.
  *
  * @param {string} str
- * @returns {string|undefined}
+ * @return {function}
  * @private
  */
+
 function firstchar (str) {
   var match = FIRST_CHAR_REGEXP.exec(str)
 
@@ -136,10 +184,10 @@ function firstchar (str) {
  * Normalize a SyntaxError for JSON.parse.
  *
  * @param {SyntaxError} error
- * @param {Object} obj
- * @returns {SyntaxError}
- * @private
+ * @param {object} obj
+ * @return {SyntaxError}
  */
+
 function normalizeJsonSyntaxError (error, obj) {
   var keys = Object.getOwnPropertyNames(error)
 

node_modules/body-parser/lib/types/raw.js

@@ -11,8 +11,10 @@
  */
 
 var debug = require('debug')('body-parser:raw')
+var isFinished = require('on-finished').isFinished
 var read = require('../read')
-var { normalizeOptions, passthrough } = require('../utils')
+var typeis = require('type-is')
+var { normalizeOptions } = require('../utils')
 
 /**
  * Module exports.
@@ -23,20 +25,51 @@ module.exports = raw
 /**
  * Create a middleware to parse raw bodies.
  *
- * @param {Object} [options]
- * @returns {Function}
- * @public
+ * @param {object} [options]
+ * @return {function}
+ * @api public
  */
-function raw (options) {
-  const normalizedOptions = normalizeOptions(options, 'application/octet-stream')
 
-  const readOptions = {
-    ...normalizedOptions,
-    // Skip charset validation and parse the body as is
-    skipCharset: true
+function raw (options) {
+  var { inflate, limit, verify, shouldParse } = normalizeOptions(options, 'application/octet-stream')
+
+  function parse (buf) {
+    return buf
   }
 
   return function rawParser (req, res, next) {
-    read(req, res, next, passthrough, debug, readOptions)
+    if (isFinished(req)) {
+      debug('body already parsed')
+      next()
+      return
+    }
+
+    if (!('body' in req)) {
+      req.body = undefined
+    }
+
+    // skip requests without bodies
+    if (!typeis.hasBody(req)) {
+      debug('skip empty body')
+      next()
+      return
+    }
+
+    debug('content-type %j', req.headers['content-type'])
+
+    // determine if request should be parsed
+    if (!shouldParse(req)) {
+      debug('skip parsing')
+      next()
+      return
+    }
+
+    // read
+    read(req, res, next, parse, debug, {
+      encoding: null,
+      inflate,
+      limit,
+      verify
+    })
   }
 }

node_modules/body-parser/lib/types/text.js

@@ -11,8 +11,10 @@
  */
 
 var debug = require('debug')('body-parser:text')
+var isFinished = require('on-finished').isFinished
 var read = require('../read')
-var { normalizeOptions, passthrough } = require('../utils')
+var typeis = require('type-is')
+var { getCharset, normalizeOptions } = require('../utils')
 
 /**
  * Module exports.
@@ -23,14 +25,56 @@ module.exports = text
 /**
  * Create a middleware to parse text bodies.
  *
- * @param {Object} [options]
- * @returns {Function}
- * @public
+ * @param {object} [options]
+ * @return {function}
+ * @api public
  */
+
 function text (options) {
-  const normalizedOptions = normalizeOptions(options, 'text/plain')
+  var { inflate, limit, verify, shouldParse } = normalizeOptions(options, 'text/plain')
+
+  var defaultCharset = options?.defaultCharset || 'utf-8'
+
+  function parse (buf) {
+    return buf
+  }
 
   return function textParser (req, res, next) {
-    read(req, res, next, passthrough, debug, normalizedOptions)
+    if (isFinished(req)) {
+      debug('body already parsed')
+      next()
+      return
+    }
+
+    if (!('body' in req)) {
+      req.body = undefined
+    }
+
+    // skip requests without bodies
+    if (!typeis.hasBody(req)) {
+      debug('skip empty body')
+      next()
+      return
+    }
+
+    debug('content-type %j', req.headers['content-type'])
+
+    // determine if request should be parsed
+    if (!shouldParse(req)) {
+      debug('skip parsing')
+      next()
+      return
+    }
+
+    // get charset
+    var charset = getCharset(req) || defaultCharset
+
+    // read
+    read(req, res, next, parse, debug, {
+      encoding: charset,
+      inflate,
+      limit,
+      verify
+    })
   }
 }

node_modules/body-parser/lib/types/urlencoded.js

@@ -14,9 +14,11 @@
 
 var createError = require('http-errors')
 var debug = require('debug')('body-parser:urlencoded')
+var isFinished = require('on-finished').isFinished
 var read = require('../read')
+var typeis = require('type-is')
 var qs = require('qs')
-var { normalizeOptions } = require('../utils')
+var { getCharset, normalizeOptions } = require('../utils')
 
 /**
  * Module exports.
@@ -27,14 +29,16 @@ module.exports = urlencoded
 /**
  * Create a middleware to parse urlencoded bodies.
  *
- * @param {Object} [options]
- * @returns {Function}
+ * @param {object} [options]
+ * @return {function}
  * @public
  */
-function urlencoded (options) {
-  const normalizedOptions = normalizeOptions(options, 'application/x-www-form-urlencoded')
 
-  if (normalizedOptions.defaultCharset !== 'utf-8' && normalizedOptions.defaultCharset !== 'iso-8859-1') {
+function urlencoded (options) {
+  var { inflate, limit, verify, shouldParse } = normalizeOptions(options, 'application/x-www-form-urlencoded')
+
+  var defaultCharset = options?.defaultCharset || 'utf-8'
+  if (defaultCharset !== 'utf-8' && defaultCharset !== 'iso-8859-1') {
     throw new TypeError('option defaultCharset must be either utf-8 or iso-8859-1')
   }
 
@@ -47,24 +51,60 @@ function urlencoded (options) {
       : {}
   }
 
-  const readOptions = {
-    ...normalizedOptions,
-    // assert charset
-    isValidCharset: (charset) => charset === 'utf-8' || charset === 'iso-8859-1'
-  }
-
   return function urlencodedParser (req, res, next) {
-    read(req, res, next, parse, debug, readOptions)
+    if (isFinished(req)) {
+      debug('body already parsed')
+      next()
+      return
+    }
+
+    if (!('body' in req)) {
+      req.body = undefined
+    }
+
+    // skip requests without bodies
+    if (!typeis.hasBody(req)) {
+      debug('skip empty body')
+      next()
+      return
+    }
+
+    debug('content-type %j', req.headers['content-type'])
+
+    // determine if request should be parsed
+    if (!shouldParse(req)) {
+      debug('skip parsing')
+      next()
+      return
+    }
+
+    // assert charset
+    var charset = getCharset(req) || defaultCharset
+    if (charset !== 'utf-8' && charset !== 'iso-8859-1') {
+      debug('invalid charset')
+      next(createError(415, 'unsupported charset "' + charset.toUpperCase() + '"', {
+        charset: charset,
+        type: 'charset.unsupported'
+      }))
+      return
+    }
+
+    // read
+    read(req, res, next, parse, debug, {
+      encoding: charset,
+      inflate,
+      limit,
+      verify
+    })
   }
 }
 
 /**
  * Get the extended query parser.
  *
- * @param {Object} options
- * @returns {Function}
- * @private
+ * @param {object} options
  */
+
 function createQueryParser (options) {
   var extended = Boolean(options?.extended)
   var parameterLimit = options?.parameterLimit !== undefined
@@ -96,7 +136,7 @@ function createQueryParser (options) {
       })
     }
 
-    var arrayLimit = extended ? Math.max(100, paramCount) : paramCount
+    var arrayLimit = extended ? Math.max(100, paramCount) : 0
 
     debug('parse ' + (extended ? 'extended ' : '') + 'urlencoding')
     try {
@@ -127,16 +167,11 @@ function createQueryParser (options) {
  *
  * @param {string} body
  * @param {number} limit
- * @returns {number|undefined} Returns undefined if limit exceeded
- * @private
+ * @api private
  */
+
 function parameterCount (body, limit) {
-  let count = 0
-  let index = -1
-  do {
-    count++
-    if (count > limit) return undefined // Early exit if limit exceeded
-    index = body.indexOf('&', index + 1)
-  } while (index !== -1)
-  return count
+  var len = body.split('&').length
+
+  return len > limit ? undefined : len - 1
 }

node_modules/body-parser/lib/utils.js

@@ -11,19 +11,19 @@ var typeis = require('type-is')
 /**
  * Module exports.
  */
+
 module.exports = {
   getCharset,
-  normalizeOptions,
-  passthrough
+  normalizeOptions
 }
 
 /**
  * Get the charset of a request.
  *
- * @param {Object} req
- * @returns {string | undefined}
- * @private
+ * @param {object} req
+ * @api private
  */
+
 function getCharset (req) {
   try {
     return (contentType.parse(req).parameters.charset || '').toLowerCase()
@@ -36,9 +36,9 @@ function getCharset (req) {
  * Get the simple type checker.
  *
  * @param {string | string[]} type
- * @returns {Function}
- * @private
+ * @return {function}
  */
+
 function typeChecker (type) {
   return function checkType (req) {
     return Boolean(typeis(req, type))
@@ -48,10 +48,9 @@ function typeChecker (type) {
 /**
  * Normalizes the common options for all parsers.
  *
- * @param {Object} options options to normalize
- * @param {string | string[] | Function} defaultType default content type(s) or a function to determine it
- * @returns {Object}
- * @private
+ * @param {object} options options to normalize
+ * @param {string | string[] | function} defaultType default content type(s) or a function to determine it
+ * @returns {object}
  */
 function normalizeOptions (options, defaultType) {
   if (!defaultType) {
@@ -65,7 +64,6 @@ function normalizeOptions (options, defaultType) {
     : options?.limit
   var type = options?.type || defaultType
   var verify = options?.verify || false
-  var defaultCharset = options?.defaultCharset || 'utf-8'
 
   if (verify !== false && typeof verify !== 'function') {
     throw new TypeError('option verify must be function')
@@ -80,19 +78,6 @@ function normalizeOptions (options, defaultType) {
     inflate,
     limit,
     verify,
-    defaultCharset,
     shouldParse
   }
 }
-
-/**
- * Passthrough function that returns input unchanged.
- * Used by parsers that don't need to transform the data.
- *
- * @param {*} value
- * @returns {*}
- * @private
- */
-function passthrough (value) {
-  return value
-}