Tag delimiters should be filtered out.

Configure gray-matter to use '' as the excerpt separator.

The fix is to convert all dashes, i.e. - to forward slashes, i.e. / in the date string before calling Date.parse in module getPostTimeStampFromPostPath.

Pass the data source declared in a template's front matter and assets.json to its components.

Error logging format needs to be normalized across the project.

This is experimental and may be removed in the future.

The fix is to refactor module composeTokens.ts to replace baseURL with "" when process.env["BUILD_STRATEGY"] equals "DEVELOPMENT". This will replace all instance of {baseURL} found in document URLs with "" when the build strategy is targeting development.

Posts aren't required to have one or more categories, which are really only used as an extension of their out path structure. Therefore, the out path of a post which doesn't provide a category should be determined the same was as the paths for files that aren't posts.

This will allow seamless functionality for components as they will not have to distinguish between development and release builds, such as having to filter out wips for example.

Users can treat their project's templates as works in progress by adding those templates' paths to their fusion.json configuration file's "wips" property:

{
    "wips": ["src/templates/yada.html"]
}

During builds using the release build strategy, fusion will not serialize those templates' generated documents and will include a counter of the number of documents that were not serialized.
During builds using the development build strategy, fusion will serialize those templates' generated documents.

Hydration required refactoring so that it doesn't continue to run when the typescript compiler reports errors.
If errors are reported, an error message should be logged and hydration should return the assets that it was called with.

Types declared in types/types.ts need to import types declared in other files (e.g. gray-matter) using import type .... This has the effect of making the types/types.ts file a module and therefore that requires that any other module that relies on its types must then import those types from types/types.ts.

The url can be obtained from getting asset.htmlDocumentName path minus its file name.
This needs to be done in the discover.ts and makeNewAsset.ts modules.

This will dramatically reduce build times.

Support WIP Folders

Users should be able to ignore folders as well as individual files.
When ignoring folders the path declared in fusion.json wips must end with a forward slash, i.e. /.

"wips": [
  "src/templates/docs/"
]

Templates that match paths that begin with a ! character should be ignored.

"wips": [
  "src/templates/docs/",
 "!src/templates/docs/index.html"
]

Note: wips should be sorted in ascending order when the configuration file is created. Sorting is necessary to insure that wip that are to be ignored are evaluated first.

Set the following Typescript compiler option to true:

• "noUnusedLocals"
• noUnusedParameters"

Ignores templates that have wip in their front matter.

• User components should return JSX, not HTML.
• This eliminates the need for user components having to call render-to-string.
• This eliminates the need for components having to import render-to-string in user projects.
• This eliminates the dependency on preact's render to string in user projects.

Implementation

As components would no longer be returning a string of HTML and will be returning jSX both hydration processing and collection processing will now have to call preact's render-to-string to convert the JSX returned by components to HTML prior to updating content.

String properties wind up with extra quotes, e.g. {aStringProp: '"value"'}. These need to be removed.

index for collections isn't being passed in props.

fusion.ssg needs a logo that unequivocally communicates what it is. If you are a graphic artist and would like to contribute to the fusion.ssg project then this is a great opportunity.

The build strategy is determined by the CLI and is based on the command that it receives. Build strategies dictate the strategy that fusion is to use to build the project. Currently there is only one build strategy, which is dev, but additional ones will be added as fusion supports other build strategies, such as release.

If a component can not be resolved from its component token path then all processing for that component token should be bypassed.

Support for:

• Articles
• Categories
• Tags

This can happen when a component does not export a function whose name matches the name provided by a component token path.

Resolve simple tokens from a data source declared in a template's front matter.

When generating a new collection asset, the module name of the collection tag should be added to each generated template's front matter and would serve as the collection's name. This would permit easy querying of assets to acquire those of a specific collection.

Implementation

Add a new property, memberOf: string to Asset. It's value should be set to the collection component's module name.

A collection component tag:

<TeamMember isCollection />

The above collection component's module name is TeamMember, which is assigned to the asset's teamMember property.

Assets:

memberOf: "TeamMember"

Use Custom Components Instead Of Component Tokens

Custom component tags must be self closing and component names must be in Pascal Case.

• <MyComponent /> - declares component named MyComponent
• <MyComponent dataSource="team.json, ..." /> - declares component named MyComponent and its data sources
• <MyComponent isCollection dataSource="team.json, ..." /> - declares collection component named MyComponent and its data sources

Support For Simple Tokens Should Be Retained

• Support for components declared using triple brackets will be dropped.
• Support for components declared using single brackets, ie. {}, that are replaced by front matter should be retained.

Details to follow.

If template front matter doesn't declare a page property then default associated page to src/pages/default.html.

Important: When fusion generates a uer project, the default.html page should be created as well.

Currently 'Template' is used to describe an HTML file that 'Pages' are inserted into. However, template is generally understood to mean a partial or an HTML template. Therefore I think it is better to use terms as they are commonly understood and so these should be renamed accordingly.

Yada needs to be refactored to implement these changes and user projects need to be refactored to use the appropriate folder names for these two project assets.

Tokenization currently occurs as part of composition, which occurs prior to collection processing. As such, any tokens contributed to a document by a collection, including their custom components, will never be resolved.

The fix is to make token processing its own service and call it immediately before serialization. This will safeguard any future problems should additional types of tokenizing be implemented.

These folders and their content need to be copied to the build folder:

• css
• scripts
• media
• etc

It is being serialized to the default posts folder name, which is posts.

Wips shouldn't have to include src/templates in their declarations.

Metrics allow for the precise timing of processes which can provide valuable information during development as well as to the end user when reporting issues.

Support Base URLs

This is for those who want to use Github pages without a domain.

It would convert the following url

<a href="/path/to/page.html"></a>

to

<a href="{baseurl}/path/to/page.html"></a>

Configuration

This would be configured by the user using their user configuration file:

{
    baseURL: "base.url.path"
}

Implementation

During composition all {baseURL} markers would be replaced with the value of baseURL taken from the user's configuration file.

This will be useful if and when incremental builds are supported.

Referring to them as tokens rather than as markers is more semantically aligned with their actually use case.

Add support for composition using components and component tokens whose paths point to components.

Components can be implemented using .js, .jsx, .ts, .tsx. They are dynamically loaded and are declared in component tokens whose content are paths that point to the components in the src/components folder. Components are called asynchronously. The content returned by components replaces their associated component tokens.

For both collection and non collection components.

This will allow sorting posts by their post date, among other use cases.

Currently Supporting urls that point to folders that contain index.html files:

-- path/to/page/
|-- index.html : currently supported

Could support urls that directly point to html files:

-- name.html

Append to the log after each build cycle. Log should wrap around after n number of entries.

After merging the default config's user settings with the user's setting, check if the userConfig.postsFolder property is set to "". If it is, replace it with "posts".

Rename user project configuration file name to fusion.json.

Add package @4awpawz/fusion-typescript-project-generator/ once it is stable.