Yearly Pages

[stdword]

inspired by this Obsidian video and @inzagi1's question

2024-08-15.15.04.31.mp4

Steps

0. Setup «Weekly Pages» with this manual and «Monthly Pages» with this one.

1. Install Block Calendar plugin to create year overview calendar.

2. Install Missing Commands plugin to create tabular view for quarter breakdown.

3. Let's prepare the query for monthly records. Create anywhere in Logseq (ex: in «Queries» page) the following query (use copy button in the top right corner):

   reference:: #monthly
   #+BEGIN_QUERY
   {
    :collapsed? false
    :inputs [:current-block :current-page]
    :query [
      :find (pull ?b [*])
      :in $ ?self ?name %
      :where
        [?b :block/page ?p]
        (referenced-by-property ?p :year ?name)
        (tagged-with-property ?b ?self :reference)
    ]
    :rules [
        [(tagged-with-property ?block ?props-block ?prop)
          [?props-block :block/properties-text-values ?props]
          [(get ?props ?prop) ?tag]
          [(subs ?tag 1) ?tag-name]
          [?block :block/refs ?ref]
          [?ref :block/name ?name]
          [(= ?name ?tag-name)]
        ],
        [(referenced-by-property ?entity ?prop ?ref)
          [?entity :block/properties ?props]
          [(get ?props ?prop) ?val]
          [(contains? ?val ?ref)]
        ]
    ]
   }
   #+END_QUERY

   Restriction: currently there is no way in Logseq to avoid copying of other queries, so they are hardcoded in template body. Please vote for this feature here and like this comment.

4. Create 🏛template anywhere in Logseq (ex: in «Templates» page). (Use copy button in the top right corner):

   - template:: yearly page
     template-version:: 1
     plugin-version:: 4.0.0
     link:: [Yearly Pages](https://github.com/stdword/logseq13-full-house-plugin/discussions/48)
     arg-day-format:: MMM, Do
     arg-week-format:: YYYY-[W]W
     arg-month-format:: YYYY-MM
     collapsed:: true
       - ```javascript
         ``{
             var monthSeparator = '<span style="display: inline-block; height: 265px; border-right: 1px solid; border-color: var(--lx-gray-04-alpha, var(--ls-guideline-color, var(--rx-gray-04-alpha)));">&nbsp;&nbsp;&nbsp;</span>'
         
             var dayFormat = d => d.format(c.args['day-format'])
             var weekFormat = d => d.format(c.args['week-format'])
             var monthFormat = d => d.format(c.args['month-format'])
             var queryFormat = d => d.format('YYYYMMDD')
         
             var page = c.page.name.match(/(\d{4})/)
             if (!page) {
                 await logseq.UI.show_msg('This is not a yearly page')
                 return
             }
             var [_missing, year] = page
             year = Number(year)
         
             var start = date.from(c.page.name).startOf('year')
             var end = start.endOf('year')
         
             outn('year-start:: ' + queryFormat(start))
             outn('year-end:: ' + queryFormat(end))
         
             // get all weeks
             var weeks = []
             var weekStart = start.startOf('isoWeek')
             let i = 1
             while (true) {
                 if (weekStart.isAfter(start, 'year'))
                     break
                 var weekEnd = weekStart.endOf('isoWeek')
                 var week = Number(weekStart.format('W'))
                 weeks.push([week, weekStart, weekEnd])
                 weekStart = weekStart.add(1, 'week')
                 if (i++ > 60)
                   break
             }
         
             // group weeks by month
             var monthNames = date.from.months()
             var weeksByMonth = {}
             for (let i = 0; i < 12; i++)
                 weeksByMonth[i] = weeks.filter(([w, s, e]) => {
                     if (s.year() === year && s.month() === i)
                       return true
                     if (e.year() === year && e.month() === i)
                       return true
                     return false
                 })
         
             var getMonthLabelAndWeeks = function (month) {
                 var monthRef = monthFormat(date.from(`${year}-${month + 1}`))
                 var weeksForMonth = weeksByMonth[month].map(([w, s, e]) => {
                     var weekRef = month === 0 && week.toString().length > 1 ? weekFormat(s) : weekFormat(e)
                     var weekLabel = weekRef.split('-')[1]
                     return `
                       [${weekLabel}]([[${weekRef}]]) [:span [:font {:size 2.8} "${dayFormat(s)} - ${dayFormat(e)}"]]
                     `.trim()
                 })
         
                 return [`[${monthNames[month]}]([[${monthRef}]])`, weeksForMonth]
             }
         
             var generateWeeksOverviewForMonthBlock = function (month, suffix = '') {
                 var [label, weeks] = getMonthLabelAndWeeks(month)
                 return `### ${label} ${suffix}` + '\n' + `${weeks.join('\n')}`
             }
         
             var generateWeeksBreakdownForMonthBlock = function (month) {
                 var [label, weeks] = getMonthLabelAndWeeks(month)
                 for (let text of weeks)
                     blocks.spawn(text)
                 return `${label}` + '\n' + `heading:: true`
             }
         
             var getWeeklyByMonthQuery = function (month) {
                 var monthRef = monthFormat(date.from(`${year}-${month + 1}`))
                 return `
         #+BEGIN_QUERY
         {
         :title [:p [:font {:size 4} [:b "${monthNames[month]}"]] ]
         :collapsed? false
         :inputs [:current-block "${monthRef}"]
         :query [
          :find (pull ?b [*])
          :in $ ?self ?month %
          :where
            [?b :block/page ?p]
            (referenced-by-property ?p :month ?month)
            (tagged-with-property ?b ?self :reference)
         ]
         :rules [
            [(tagged-with-property ?block ?props-block ?prop)
              [?props-block :block/properties-text-values ?props]
              [(get ?props ?prop) ?tag]
              [(subs ?tag 1) ?tag-name]
              [?block :block/refs ?ref]
              [?ref :block/name ?name]
              [(= ?name ?tag-name)]
            ],
            [(referenced-by-property ?entity ?prop ?ref)
              [?entity :block/properties ?props]
              [(get ?props ?prop) ?val]
              [(contains? ?val ?ref)]
            ]
         ]
         }
         #+END_QUERY
               `.trim()
             }
         
             var generateWeeklyByMonthBlock = function () {
               return [...Array(12).keys()]
                 .map(getWeeklyByMonthQuery)
                 .join('\n')
             }
         
             var getOverviewByMonthQuery = function (month) {
                 var monthObj = date.from(`${year}-${month + 1}`)
                 var start = queryFormat(monthObj.startOf('month'))
                 var end = queryFormat(monthObj.endOf('month'))
                 return `
         #+BEGIN_QUERY
         {:title [:p [:font {:size 4} [:b "${monthNames[month]}"]] ]
         :collapsed? true
         :inputs [:current-block ${start} ${end}]
         :query [
          :find (pull ?b [*])
          :in $ ?self ?start ?end %
          :where
            (between ?b ?start ?end)
            (tagged-with-property ?b ?self :reference)
         ]
         :rules [
            [(tagged-with-property ?block ?props-block ?prop)
              [?props-block :block/properties-text-values ?props]
              [(get ?props ?prop) ?tag]
              [(subs ?tag 1) ?tag-name]
              [?block :block/refs ?ref]
              [?ref :block/name ?name]
              [(= ?name ?tag-name)]
            ]
         ]
         }
         #+END_QUERY
               `.trim()
             }
         
             var generateOverviewByMonthBlock = function () {
               return [...Array(12).keys()]
                 .map(getOverviewByMonthQuery)
                 .join('\n')
             }
         }``
         ```
       - Day journals
         heading:: true
         collapsed:: true
         ``{ outn('collapsed:: true') }``
           - {{renderer :days-year, @}}
             ``{ outn('collapsed:: true') }``
               - ```javascript
                 ``{ var backticks = '```' }``
                 ``backticks``clojure
                 [:find (pull ?j [*])
                  :where
                  [?j :block/journal? true]
                  [?j :block/journal-day ?day]
                  [(str ?day) ?day-s]
                  [(subs ?day-s 0 4) ?year]
                  [(= ?year "``year``")]
                 ]
                 ``backticks``
                 ```
           - {{renderer block-calendar-yearly, ``year``, nonav | nohead}}
       - Week & Month journals
         heading:: true
           - Overview
             heading:: true
               - ``generateWeeksOverviewForMonthBlock(0, '#.side-m')``
                   - ``generateWeeksOverviewForMonthBlock(1, '#.side-m')``
                       - ``generateWeeksOverviewForMonthBlock(2)``
               - ``generateWeeksOverviewForMonthBlock(3, '#.side-m')``
                   - ``generateWeeksOverviewForMonthBlock(4, '#.side-m')``
                       - ``generateWeeksOverviewForMonthBlock(5)``
               - ``generateWeeksOverviewForMonthBlock(6, '#.side-m')``
                   - ``generateWeeksOverviewForMonthBlock(7, '#.side-m')``
                       - ``generateWeeksOverviewForMonthBlock(8)``
               - ``generateWeeksOverviewForMonthBlock(9, '#.side-m')``
                   - ``generateWeeksOverviewForMonthBlock(10, '#.side-m')``
                       - ``generateWeeksOverviewForMonthBlock(11)``
           - Overview (for wide mode)
             heading:: true
               - ``{ var renderDays = (m) => `{{renderer :days, @, -, ${year}, ${m} }}` }``
                 ``renderDays(1)``
                 ``{_ for (let i = 2; i <= 12; i++) out(monthSeparator + renderDays(i)) }``
                   - ```javascript
                     ``{ var backticks = '```' }``
                     ``backticks``clojure
                     [:find (pull ?j [*])
                      :where
                      [?j :block/journal? true]
                      [?j :block/journal-day ?day]
                      [(str ?day) ?day-s]
                      [(subs ?day-s 0 4) ?year]
                      [(= ?year "``year``")]
                     ]
                     ``backticks``
                     ```
           - Quarter Breakdown #.tabular
             heading:: true
             collapsed:: true
             (for comments)
               - Q1 #.tabular
                 heading:: true
                   - ``generateWeeksBreakdownForMonthBlock(0)``
                   - ``generateWeeksBreakdownForMonthBlock(1)``
                   - ``generateWeeksBreakdownForMonthBlock(2)``
               - Q2 #.tabular
                 heading:: true
                   - ``generateWeeksBreakdownForMonthBlock(3)``
                   - ``generateWeeksBreakdownForMonthBlock(4)``
                   - ``generateWeeksBreakdownForMonthBlock(5)``
               - Q3 #.tabular
                 heading:: true
                   - ``generateWeeksBreakdownForMonthBlock(6)``
                   - ``generateWeeksBreakdownForMonthBlock(7)``
                   - ``generateWeeksBreakdownForMonthBlock(8)``
               - Q4 #.tabular
                 heading:: true
                   - ``generateWeeksBreakdownForMonthBlock(9)``
                   - ``generateWeeksBreakdownForMonthBlock(10)``
                   - ``generateWeeksBreakdownForMonthBlock(11)``
           -
           - Records
             heading:: true
               - INSERT HERE embed ref for #monthly records
               - ``generateWeeklyByMonthBlock()``
                 reference:: #weekly
                 collapsed:: true
       - Podcasts overview
         heading:: true
           - {{renderer :days-year, @}}
             collapsed:: true
               - ```javascript
                 ``{ var backticks = '```' }``
                 ``backticks``clojure
                 [:find (pull ?j [*])
                  :where
                  [?j :block/journal? true]
                  [?j :block/journal-day ?day]
                  [(str ?day) ?day-s]
                  [(subs ?day-s 0 4) ?year]
                  [(= ?year "``year``")]
                  [?jb :block/page ?j]
                  [?jb :block/refs ?ref]
                  [?ref :block/name ?name]
                  [(= ?name "podcast")]
                 ]
                 ``backticks``
                 ```
           - ``generateOverviewByMonthBlock()``
             reference:: #podcast
             collapsed:: true
       - Diary overview
         heading:: true
           - {{renderer :days-year, @}}
             collapsed:: true
               - ```javascript
                 ``{ var backticks = '```' }``
                 ``backticks``clojure
                 [:find (pull ?j [*])
                  :where
                  [?j :block/journal? true]
                  [?j :block/journal-day ?day]
                  [(str ?day) ?day-s]
                  [(subs ?day-s 0 4) ?year]
                  [(= ?year "``year``")]
                  [?jb :block/page ?j]
                  [?jb :block/refs ?ref]
                  [?ref :block/name ?name]
                  [(= ?name "diary")]
                 ]
                 ``backticks``
                 ```
           - ``generateOverviewByMonthBlock()``
             reference:: #diary
             collapsed:: true

5. Copy reference to query created before via right clicking on corresponding bullet and selecting «Copy block embed»:
   
   …and insert them replacing line with «INSERT HERE» text in the template (there are three lines). It should look like:

   …
   - {{embed ((666cd068-133c-4b30-9df4-1dd8a94179cb))}}
   …
   

6. Now, let's install and setup Default Template plugin to automatically insert 🏛️template. Create another template:

   - template:: .yearly page inserter
     template-including-parent:: false
     - {{renderer :template, yearly page, :delay-until-rendered}}
     - 
   

   And add \d{4}::.yearly page inserter text to Default Template plugin's setting /advancedRegex:
   

7. Additionally you can setup Awesome Links plugin to have colored references to Monthly Pages (according to type:: month):

   • Goto plugin settings (t s) → Awesome Links and set the inheritFromProp setting to type:
     
   • Go to [[month]] page and add page property color:: mediumseagreen (choose any value you want via this service).

❤️ Enjoy the full automatic monthly page creation!

FAQ

Why are queries embedded instead of being written directly in the template?

Because if you want to change the query, you would only need to modify it in one place - and the changes will be immediately visible on all already created weekly pages. This is very handy. But if you don't need this - you can do without embed and each time "enclose" the query inside the weekly page. Then, when changing the query in the template, only new pages will see its new look.

Why is the property reference:: with the value #podcast displayed in the query block?

1. Visually, it's clear what type of data we're looking at. Although you could use the query title for this, or simply write the heading "Podcasts Overview".
2. For an easy configuration, if you suddenly want to change #podcast to something else (for example, to #youtube-video).
3. To have a block with a query in Linked References, on the podcast page. This is handy if you want to rename the podcast page (e.g. to 🎙️). The block with the query will be renamed automatically. If it is not in Linked References, you will have to a) remember that the block with the query on the pages requires manual modification b) carry out this manual modification.

• If you want to hide this property, you can do this via custom.css:

  .block-properties > div:has(.page-property-key[data-ref="reference"]) {
      display: none !important;
  }

  At the same time, the property continues to be visible in edit mode, which is handy if you need to change its value.

See also

• Weekly Pages setup
• Monthly Pages setup

Additional info

• Logseq v0.10.9
• ☕️ BuJo Theme
• discuss.logseq.com