NE.Standard 1.0.0

NE.Standard

A server-driven UI framework for .NET, plus the general-purpose helper library it grew out of.

You write a view — a component tree, in C# fluent builders — and a controller — an observable object graph. The framework compiles that pair once into an immutable, indexed description, renders it to a platform, and then keeps the rendered surface in sync with the controller in both directions. The client never holds application state and never decides what to draw.

Web is the platform implemented today: ASP.NET Core for the shell and the transport, SignalR for the live channel, and a TypeScript client that ships embedded in the assembly — there is no separate front-end deploy step.

Packages

The rest of the framework — the contracts, the engine, the components and the web platform — is still moving and is not published yet. docs/PLAN.md in the private repository tracks what is left before it is.

dotnet add package NE.Standard

The same versions also go to GitHub Packages, which needs the feed added with credentials first — it authenticates every read, public package or not:

dotnet nuget add source https://nuget.pkg.github.com/AkiEvansDev/index.json -n akievansdev -u <user> -p <token>

A first look

A view declares the tree and what each part binds to:

internal sealed class CounterView : UIViewBase, IUIViewDefinition
{
    public static string ViewKey => "counter";

    protected override IVisualComponent CreateContent()
        => new ContainerComponent()
            .SetPadding(new UIThickness(16))
            .AddChild(new TextComponent()
                .BindTitle(nameof(CounterController.Count))
                .SetPlacement(1, 1, 24, 1)
            )
            .AddChild(new ButtonComponent()
                .OnClick(nameof(CounterController.Increment))
                .ConfigureDefaultContent(c => c.SetTitle("Add one"))
                .SetPlacement(1, 2, 24, 1)
            );
}

A controller holds the state, and changing it is what updates the screen — [RecursiveMember] generates the notifying setter and the path segment the binding resolves against:

internal sealed partial class CounterController : UIControllerBase
{
    [RecursiveMember]
    public partial int Count { get; set; }

    [UICommand]
    public void Increment() => Count++;
}

Hosting is an ASP.NET Core application:

WebApplicationBuilder builder = WebApplication.CreateBuilder(args);

WebStartupBuilder.Configure<AppWebStartup, AppStartup>(builder.Services);

WebApplication app = builder.Build();
await app.MapStandardUIWebAsync();
await app.RunAsync();

The demo

examples/DemoApp is the reference application: every built-in component, each shown three ways — a static example, a live binding playground and an interaction test — across 87 routes, with a worked authentication/authorization section.

dotnet run --project examples/DemoApp.Web    # http://localhost:5000

Building

Requires the .NET 10 SDK, and Node for the TypeScript client — which builds as part of dotnet build, so a TypeScript type error fails the .NET build.

dotnet build
dotnet build -p:SkipWebClientBuild=true      # skip npm/vite when node is unavailable

Contributing

This repository is a read-only mirror of a private one, so a merged pull request here would be erased by the next release. Please open an issue instead — the change is made upstream and appears here with the next release.

License

MIT.